X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=server_%2Fgame.py;h=554bce6fb13f462e1e25878bbea0efaf4a02b66c;hb=52463b31fbb7f121a52f72e863a779560a6de531;hp=4cd28fba99b2ba13426da0563482ca5d21723209;hpb=64bf1873a6686c1bc974321c13d3c9f7800db0d6;p=plomrogue2-experiments diff --git a/server_/game.py b/server_/game.py index 4cd28fb..554bce6 100644 --- a/server_/game.py +++ b/server_/game.py @@ -2,20 +2,20 @@ import sys sys.path.append('../') import game_common import server_.map_ - - -class GameError(Exception): - pass +import server_.io +import server_.tasks +from server_.game_error import GameError +from parser import ArgError class World(game_common.World): - def __init__(self): + def __init__(self, game): super().__init__() + self.game = game self.player_id = 0 # use extended local classes self.Thing = Thing - self.get_map_class = server_.map_.get_map_class def proceed_to_next_player_turn(self): """Run game world turns until player can decide their next step. @@ -44,56 +44,114 @@ class World(game_common.World): def get_player(self): return self.get_thing(self.player_id) + def make_new(self, geometry, yx, seed): + import random + random.seed(seed) + self.turn = 0 + self.new_map(geometry, yx) + for pos in self.map_: + if 0 in pos or (yx[0] - 1) == pos[0] or (yx[1] - 1) == pos[1]: + self.map_[pos] = '#' + continue + self.map_[pos] = random.choice(('.', '.', '.', '.', 'x')) + player = self.Thing(self, 0) + player.type_ = 'human' + player.position = [random.randint(0, yx[0] -1), + random.randint(0, yx[1] - 1)] + npc = self.Thing(self, 1) + npc.type_ = 'monster' + npc.position = [random.randint(0, yx[0] -1), + random.randint(0, yx[1] -1)] + self.things = [player, npc] -class Task: - def __init__(self, thing, name, args=(), kwargs={}): - self.name = name - self.thing = thing - self.args = args - self.kwargs = kwargs - self.todo = 3 + return 'success' - def check(self): - if self.name == 'move': - if len(self.args) > 0: - direction = self.args[0] - else: - direction = self.kwargs['direction'] - test_pos = self.thing.world.map_.move(self.thing.position, direction) - if self.thing.world.map_[test_pos] != '.': - raise GameError('would move into illegal terrain') - for t in self.thing.world.things: - if t.position == test_pos: - raise GameError('would move into other thing') class Thing(game_common.Thing): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) - self.task = Task(self, 'wait') - self.last_task_result = None + self.task = self.world.game.task_manager.get_task_class('WAIT')(self) + self._last_task_result = None self._stencil = None - def task_wait(self): - return 'success' - - def task_move(self, direction): - self.position = self.world.map_.move(self.position, direction) - return 'success' + def move_towards_target(self, target): + dijkstra_map = type(self.world.map_)(self.world.map_.size) + n_max = 256 + dijkstra_map.terrain = [n_max for i in range(dijkstra_map.size_i)] + dijkstra_map[target] = 0 + shrunk = True + visible_map = self.get_visible_map() + while shrunk: + shrunk = False + for pos in dijkstra_map: + if visible_map[pos] != '.': + continue + neighbors = dijkstra_map.get_neighbors(tuple(pos)) + for direction in neighbors: + yx = neighbors[direction] + if yx is not None and dijkstra_map[yx] < dijkstra_map[pos] - 1: + dijkstra_map[pos] = dijkstra_map[yx] + 1 + shrunk = True + #with open('log', 'a') as f: + # f.write('---------------------------------\n') + # for y, line in dijkstra_map.lines(): + # for val in line: + # if val < 10: + # f.write(str(val)) + # elif val == 256: + # f.write('x') + # else: + # f.write('~') + # f.write('\n') + neighbors = dijkstra_map.get_neighbors(tuple(self.position)) + n = n_max + #print('DEBUG', self.position, neighbors) + #dirs = dijkstra_map.get_directions() + #print('DEBUG dirs', dirs) + #print('DEBUG neighbors', neighbors) + #debug_scores = [] + #for pos in neighbors: + # if pos is None: + # debug_scores += [9000] + # else: + # debug_scores += [dijkstra_map[pos]] + #print('DEBUG debug_scores', debug_scores) + target_direction = None + for direction in neighbors: + yx = neighbors[direction] + if yx is not None: + n_new = dijkstra_map[yx] + if n_new < n: + n = n_new + target_direction = direction + #print('DEBUG result', direction) + if target_direction: + self.set_task('MOVE', (target_direction,)) def decide_task(self): - if self.position[1] > 1: - self.set_task('move', 'LEFT') - elif self.position[1] < 3: - self.set_task('move', 'RIGHT') - else: - self.set_task('wait') + # TODO: Check if monster can follow player too well (even when they should lose them) + visible_things = self.get_visible_things() + target = None + for t in visible_things: + if t.type_ == 'human': + target = t.position + break + if target is not None: + try: + self.move_towards_target(target) + return + except GameError: + pass + self.set_task('WAIT') + - def set_task(self, task_name, *args, **kwargs): - self.task = Task(self, task_name, args, kwargs) - self.task.check() + def set_task(self, task_name, args=()): + task_class = self.world.game.task_manager.get_task_class(task_name) + self.task = task_class(self, args) + self.task.check() # will throw GameError if necessary def proceed(self, is_AI=True): """Further the thing in its tasks. @@ -112,26 +170,27 @@ class Thing(game_common.Thing): self.task.check() except GameError as e: self.task = None - self.last_task_result = e + self._last_task_result = e if is_AI: - self.decide_task() + try: + self.decide_task() + except GameError: + self.set_task('WAIT') return self.task.todo -= 1 if self.task.todo <= 0: - task = getattr(self, 'task_' + self.task.name) - self.last_task_result = task(*self.task.args, **self.task.kwargs) + self._last_task_result = self.task.do() self.task = None if is_AI and self.task is None: - self.decide_task() + try: + self.decide_task() + except GameError: + self.set_task('WAIT') def get_stencil(self): if self._stencil is not None: return self._stencil - m = self.world.map_.new_from_shape('?') - for pos in m: - if pos == self.position or m.are_neighbors(pos, self.position): - m[pos] = '.' - self._stencil = m + self._stencil = self.world.map_.get_fov_map(self.position) return self._stencil def get_visible_map(self): @@ -162,8 +221,9 @@ def fib(n): class Game(game_common.CommonCommandsMixin): def __init__(self, game_file_name): - import server_.io - self.world = World() + self.map_manager = server_.map_.map_manager + self.task_manager = server_.tasks.task_manager + self.world = World(self) self.io = server_.io.GameIO(game_file_name, self) # self.pool and self.pool_result are currently only needed by the FIB # command and the demo of a parallelized game loop in cmd_inc_p. @@ -174,21 +234,20 @@ class Game(game_common.CommonCommandsMixin): def send_gamestate(self, connection_id=None): """Send out game state data relevant to clients.""" - def stringify_yx(tuple_): - """Transform tuple (y,x) into string 'Y:'+str(y)+',X:'+str(x).""" - return 'Y:' + str(tuple_[0]) + ',X:' + str(tuple_[1]) - - self.io.send('NEW_TURN ' + str(self.world.turn)) - grid = self.world.map_.__class__.__name__[3:] - self.io.send('MAP ' + grid +' ' + stringify_yx(self.world.map_.size)) + self.io.send('TURN ' + str(self.world.turn)) + self.io.send('MAP ' + self.world.map_.geometry +\ + ' ' + server_.io.stringify_yx(self.world.map_.size)) visible_map = self.world.get_player().get_visible_map() for y, line in visible_map.lines(): - self.io.send('VISIBLE_MAP_LINE %5s %s' % (y, self.io.quote(line))) + self.io.send('VISIBLE_MAP_LINE %5s %s' % (y, server_.io.quote(line))) visible_things = self.world.get_player().get_visible_things() for thing in visible_things: self.io.send('THING_TYPE %s %s' % (thing.id_, thing.type_)) self.io.send('THING_POS %s %s' % (thing.id_, - stringify_yx(thing.position))) + server_.io.stringify_yx(thing.position))) + player = self.world.get_player() + self.io.send('PLAYER_POS %s' % (server_.io.stringify_yx(player.position))) + self.io.send('GAME_STATE_COMPLETE') def proceed(self): """Send turn finish signal, run game world, send new world data. @@ -198,8 +257,8 @@ class Game(game_common.CommonCommandsMixin): """ self.io.send('TURN_FINISHED ' + str(self.world.turn)) self.world.proceed_to_next_player_turn() - msg = str(self.world.get_player().last_task_result) - self.io.send('LAST_PLAYER_TASK_RESULT ' + self.io.quote(msg)) + msg = str(self.world.get_player()._last_task_result) + self.io.send('LAST_PLAYER_TASK_RESULT ' + server_.io.quote(msg)) self.send_gamestate() def cmd_FIB(self, numbers, connection_id): @@ -217,16 +276,18 @@ class Game(game_common.CommonCommandsMixin): def cmd_INC_P(self, connection_id): """Increment world.turn, send game turn data to everyone. - To simulate game processing waiting times, a one second delay between - TURN_FINISHED and NEW_TURN occurs; after NEW_TURN, some expensive - calculations are started as pool processes that need to be finished - until a further INC finishes the turn. + To simulate game processing waiting times, a one second delay + between TURN_FINISHED and TURN occurs; after TURN, some + expensive calculations are started as pool processes that need + to be finished until a further INC finishes the turn. + + This is just a demo structure for how the game loop could work + when parallelized. One might imagine a two-step game turn, + with a non-action step determining actor tasks (the AI + determinations would take the place of the fib calculations + here), and an action step wherein these tasks are performed + (where now sleep(1) is). - This is just a demo structure for how the game loop could work when - parallelized. One might imagine a two-step game turn, with a non-action - step determining actor tasks (the AI determinations would take the - place of the fib calculations here), and an action step wherein these - tasks are performed (where now sleep(1) is). """ from time import sleep if self.pool_result is not None: @@ -237,24 +298,19 @@ class Game(game_common.CommonCommandsMixin): self.send_gamestate() self.pool_result = self.pool.map_async(fib, (35, 35)) - def cmd_MOVE(self, direction): - """Set player task to 'move' with direction arg, finish player turn.""" - import parser - legal_directions = self.world.map_.get_directions() - if direction not in legal_directions: - raise parser.ArgError('Move argument must be one of: ' + - ', '.join(legal_directions)) - self.world.get_player().set_task('move', direction=direction) - self.proceed() - cmd_MOVE.argtypes = 'string' - - def cmd_WAIT(self): - """Set player task to 'wait', finish player turn.""" - self.world.get_player().set_task('wait') + def cmd_SWITCH_PLAYER(self): + player = self.world.get_player() + player.set_task('WAIT') + thing_ids = [t.id_ for t in self.world.things] + player_index = thing_ids.index(player.id_) + if player_index == len(thing_ids) - 1: + self.world.player_id = thing_ids[0] + else: + self.world.player_id = thing_ids[player_index + 1] self.proceed() def cmd_GET_GAMESTATE(self, connection_id): - """Send game state jto caller.""" + """Send game state to caller.""" self.send_gamestate(connection_id) def cmd_ECHO(self, msg, connection_id): @@ -270,3 +326,91 @@ class Game(game_common.CommonCommandsMixin): def cmd_TERRAIN_LINE(self, y, terrain_line): self.world.map_.set_line(y, terrain_line) cmd_TERRAIN_LINE.argtypes = 'int:nonneg string' + + def cmd_GEN_WORLD(self, geometry, yx, seed): + self.world.make_new(geometry, yx, seed) + cmd_GEN_WORLD.argtypes = 'string:geometry yx_tuple:pos string' + + def get_command_signature(self, command_name): + from functools import partial + + def cmd_TASK_colon(task_name, *args): + self.world.get_player().set_task(task_name, args) + self.proceed() + + def cmd_SET_TASK_colon(task_name, thing_id, todo, *args): + t = self.world.get_thing(thing_id, False) + if t is None: + raiseArgError('No such Thing.') + task_class = self.task_manager.get_task_class(task_name) + t.task = task_class(t, args) + t.task.todo = todo + + def task_prefixed(command_name, task_prefix, task_command, + argtypes_prefix=''): + func = None + argtypes = '' + if command_name[:len(task_prefix)] == task_prefix: + task_name = command_name[len(task_prefix):] + task_manager_reply = self.task_manager.get_task_class(task_name) + if task_manager_reply is not None: + func = partial(task_command, task_name) + task_class = task_manager_reply + argtypes = task_class.argtypes + if func is not None: + return func, argtypes_prefix + argtypes + return None, argtypes + + func, argtypes = task_prefixed(command_name, 'TASK:', cmd_TASK_colon) + if func: + return func, argtypes + func, argtypes = task_prefixed(command_name, 'SET_TASK:', + cmd_SET_TASK_colon, + 'int:nonneg int:nonneg ') + if func: + return func, argtypes + func_candidate = 'cmd_' + command_name + if hasattr(self, func_candidate): + func = getattr(self, func_candidate) + if hasattr(func, 'argtypes'): + argtypes = func.argtypes + return func, argtypes + + def get_string_options(self, string_option_type): + if string_option_type == 'geometry': + return self.map_manager.get_map_geometries() + elif string_option_type == 'direction': + return self.world.map_.get_directions() + return None + + def cmd_PLAYER_ID(self, id_): + # TODO: test whether valid thing ID + self.world.player_id = id_ + cmd_PLAYER_ID.argtypes = 'int:nonneg' + + def cmd_TURN(self, n): + self.world.turn = n + cmd_TURN.argtypes = 'int:nonneg' + + def cmd_SAVE(self): + + def write(f, msg): + f.write(msg + '\n') + + save_file_name = self.io.game_file_name + '.save' + with open(save_file_name, 'w') as f: + write(f, 'TURN %s' % self.world.turn) + write(f, 'MAP ' + self.world.map_.geometry + ' ' + server_.io.stringify_yx(self.world.map_.size)) + for y, line in self.world.map_.lines(): + write(f, 'TERRAIN_LINE %5s %s' % (y, server_.io.quote(line))) + for thing in self.world.things: + write(f, 'THING_TYPE %s %s' % (thing.id_, thing.type_)) + write(f, 'THING_POS %s %s' % (thing.id_, + server_.io.stringify_yx(thing.position))) + task = thing.task + if task is not None: + task_args = task.get_args_string() + write(f, 'SET_TASK:%s %s %s %s' % (task.name, thing.id_, + task.todo, task_args)) + write(f, 'PLAYER_ID %s' % self.world.player_id) + cmd_SAVE.dont_save = True