plomlompom.com Git - plomrogue2-experiments/blob - new/plomrogue/game.py

   1 from plomrogue.tasks import Task_WAIT, Task_MOVE, Task_PICKUP, Task_DROP
   2 from plomrogue.errors import ArgError
   3 from plomrogue.commands import (cmd_GEN_WORLD, cmd_GET_GAMESTATE, cmd_MAP,
   4                                 cmd_MAP, cmd_THING_TYPE, cmd_THING_POS,
   5                                 cmd_THING_INVENTORY,
   6                                 cmd_TERRAIN_LINE, cmd_PLAYER_ID, cmd_TURN,
   7                                 cmd_SWITCH_PLAYER, cmd_SAVE)
   8 from plomrogue.mapping import MapHex
   9 from plomrogue.parser import Parser
  10 from plomrogue.io import GameIO
  11 from plomrogue.misc import quote, stringify_yx
  12 from plomrogue.things import Thing, ThingMonster, ThingHuman, ThingItem
  13
  14
  15
  16 class WorldBase:
  17
  18     def __init__(self, game):
  19         self.turn = 0
  20         self.things = []
  21         self.game = game
  22
  23     def get_thing(self, id_, create_unfound=True):
  24         for thing in self.things:
  25             if id_ == thing.id_:
  26                 return thing
  27         if create_unfound:
  28             t = self.game.thing_type(self, id_)
  29             self.things += [t]
  30             return t
  31         return None
  32
  33
  34
  35 class World(WorldBase):
  36
  37     def __init__(self, *args, **kwargs):
  38         super().__init__(*args, **kwargs)
  39         self.player_id = 0
  40
  41     @property
  42     def player(self):
  43         return self.get_thing(self.player_id)
  44
  45     def new_thing_id(self):
  46         if len(self.things) == 0:
  47             return 0
  48         return self.things[-1].id_ + 1
  49
  50     def new_map(self, yx):
  51         self.map_ = self.game.map_type(yx)
  52
  53     def proceed_to_next_player_turn(self):
  54         """Run game world turns until player can decide their next step.
  55
  56         Iterates through all non-player things, on each step
  57         furthering them in their tasks (and letting them decide new
  58         ones if they finish). The iteration order is: first all things
  59         that come after the player in the world things list, then
  60         (after incrementing the world turn) all that come before the
  61         player; then the player's .proceed() is run, and if it does
  62         not finish his task, the loop starts at the beginning. Once
  63         the player's task is finished, the loop breaks.
  64         """
  65         while True:
  66             player_i = self.things.index(self.player)
  67             for thing in self.things[player_i+1:]:
  68                 thing.proceed()
  69             self.turn += 1
  70             for thing in self.things[:player_i]:
  71                 thing.proceed()
  72             self.player.proceed(is_AI=False)
  73             if self.player.task is None:
  74                 break
  75
  76     def make_new(self, yx, seed):
  77         import random
  78
  79         def add_thing(type_):
  80             t = self.game.thing_types[type_](self)
  81             t.position = (random.randint(0, yx[0] -1),
  82                           random.randint(0, yx[1] - 1))
  83             self.things += [t]
  84             return t
  85
  86         self.things = []
  87         random.seed(seed)
  88         self.turn = 0
  89         self.new_map(yx)
  90         for pos in self.map_:
  91             if 0 in pos or (yx[0] - 1) == pos[0] or (yx[1] - 1) == pos[1]:
  92                 self.map_[pos] = '#'
  93                 continue
  94             self.map_[pos] = random.choice(('.', '.', '.', '.', 'x'))
  95
  96         player = add_thing('human')
  97         self.player_id = player.id_
  98         add_thing('monster')
  99         add_thing('monster')
 100         add_thing('item')
 101         add_thing('item')
 102         return 'success'
 103
 104
 105
 106 class Game:
 107
 108     def __init__(self, game_file_name):
 109         self.io = GameIO(game_file_name, self)
 110         self.map_type = MapHex
 111         self.tasks = {'WAIT': Task_WAIT,
 112                       'MOVE': Task_MOVE,
 113                       'PICKUP': Task_PICKUP,
 114                       'DROP': Task_DROP}
 115         self.commands = {'GEN_WORLD': cmd_GEN_WORLD,
 116                          'GET_GAMESTATE': cmd_GET_GAMESTATE,
 117                          'MAP': cmd_MAP,
 118                          'THING_TYPE': cmd_THING_TYPE,
 119                          'THING_POS': cmd_THING_POS,
 120                          'THING_INVENTORY': cmd_THING_INVENTORY,
 121                          'TERRAIN_LINE': cmd_TERRAIN_LINE,
 122                          'PLAYER_ID': cmd_PLAYER_ID,
 123                          'TURN': cmd_TURN,
 124                          'SWITCH_PLAYER': cmd_SWITCH_PLAYER,
 125                          'SAVE': cmd_SAVE}
 126         self.world_type = World
 127         self.world = self.world_type(self)
 128         self.thing_type = Thing
 129         self.thing_types = {'human': ThingHuman,
 130                             'monster': ThingMonster,
 131                             'item': ThingItem}
 132
 133     def get_string_options(self, string_option_type):
 134         if string_option_type == 'direction':
 135             return self.world.map_.get_directions()
 136         elif string_option_type == 'thingtype':
 137             return list(self.thing_types.keys())
 138         return None
 139
 140     def send_gamestate(self, connection_id=None):
 141         """Send out game state data relevant to clients."""
 142
 143         self.io.send('TURN ' + str(self.world.turn))
 144         self.io.send('MAP ' + stringify_yx(self.world.map_.size))
 145         visible_map = self.world.player.get_visible_map()
 146         for y, line in visible_map.lines():
 147             self.io.send('VISIBLE_MAP_LINE %5s %s' % (y, quote(line)))
 148         visible_things = self.world.player.get_visible_things()
 149         for thing in visible_things:
 150             self.io.send('THING_TYPE %s %s' % (thing.id_, thing.type_))
 151             self.io.send('THING_POS %s %s' % (thing.id_,
 152                                               stringify_yx(thing.position)))
 153         if len(self.world.player.inventory) > 0:
 154             self.io.send('PLAYER_INVENTORY %s' %
 155                          ','.join([str(i) for i in self.world.player.inventory]))
 156         else:
 157             self.io.send('PLAYER_INVENTORY ,')
 158         for id_ in self.world.player.inventory:
 159             thing = self.world.get_thing(id_)
 160             self.io.send('THING_TYPE %s %s' % (thing.id_, thing.type_))
 161             self.io.send('THING_POS %s %s' % (thing.id_,
 162                                               stringify_yx(thing.position)))
 163         self.io.send('GAME_STATE_COMPLETE')
 164
 165     def proceed(self):
 166         """Send turn finish signal, run game world, send new world data.
 167
 168         First sends 'TURN_FINISHED' message, then runs game world
 169         until new player input is needed, then sends game state.
 170         """
 171         self.io.send('TURN_FINISHED ' + str(self.world.turn))
 172         self.world.proceed_to_next_player_turn()
 173         msg = str(self.world.player._last_task_result)
 174         self.io.send('LAST_PLAYER_TASK_RESULT ' + quote(msg))
 175         self.send_gamestate()
 176
 177     def get_command(self, command_name):
 178
 179         def partial_with_attrs(f, *args, **kwargs):
 180             from functools import partial
 181             p = partial(f, *args, **kwargs)
 182             p.__dict__.update(f.__dict__)
 183             return p
 184
 185         def cmd_TASK_colon(task_name, game, *args):
 186             game.world.player.set_task(task_name, args)
 187             game.proceed()
 188
 189         def cmd_SET_TASK_colon(task_name, game, thing_id, todo, *args):
 190             t = game.world.get_thing(thing_id, False)
 191             if t is None:
 192                 raise ArgError('No such Thing.')
 193             task_class = game.tasks[task_name]
 194             t.task = task_class(t, args)
 195             t.task.todo = todo
 196
 197         def task_prefixed(command_name, task_prefix, task_command,
 198                           argtypes_prefix=None):
 199             if command_name[:len(task_prefix)] == task_prefix:
 200                 task_name = command_name[len(task_prefix):]
 201                 if task_name in self.tasks:
 202                     f = partial_with_attrs(task_command, task_name, self)
 203                     task = self.tasks[task_name]
 204                     if argtypes_prefix:
 205                         f.argtypes = argtypes_prefix + ' ' + task.argtypes
 206                     else:
 207                         f.argtypes = task.argtypes
 208                     return f
 209             return None
 210
 211         command = task_prefixed(command_name, 'TASK:', cmd_TASK_colon)
 212         if command:
 213             return command
 214         command = task_prefixed(command_name, 'SET_TASK:', cmd_SET_TASK_colon,
 215                                 'int:nonneg int:nonneg ')
 216         if command:
 217             return command
 218         if command_name in self.commands:
 219             f = partial_with_attrs(self.commands[command_name], self)
 220             return f
 221         return None