home · contact · privacy
de6f0c03d00f22a23f278b5c8dfa4c08b8c05e52
[plomrogue2-experiments] / new / plomrogue / game.py
1 from plomrogue.tasks import (Task_WAIT, Task_MOVE, Task_PICKUP,
2                              Task_DROP, Task_EAT)
3 from plomrogue.errors import ArgError, GameError
4 from plomrogue.commands import (cmd_GEN_WORLD, cmd_GET_GAMESTATE,
5                                 cmd_MAP, cmd_MAP, cmd_THING_TYPE,
6                                 cmd_THING_POS, cmd_THING_INVENTORY,
7                                 cmd_THING_HEALTH, cmd_SEED,
8                                 cmd_GET_PICKABLE_ITEMS, cmd_MAP_SIZE,
9                                 cmd_TERRAIN_LINE, cmd_PLAYER_ID,
10                                 cmd_TURN, cmd_SWITCH_PLAYER, cmd_SAVE)
11 from plomrogue.mapping import MapHex, YX
12 from plomrogue.parser import Parser
13 from plomrogue.io import GameIO
14 from plomrogue.misc import quote
15 from plomrogue.things import Thing, ThingMonster, ThingHuman, ThingFood
16 import random
17
18
19
20 class PRNGod(random.Random):
21
22     def seed(self, seed):
23         self.prngod_seed = seed
24
25     def getstate(self):
26         return self.prngod_seed
27
28     def setstate(seed):
29         self.seed(seed)
30
31     def random(self):
32         self.prngod_seed = ((self.prngod_seed * 1103515245) + 12345) % 2**32
33         return (self.prngod_seed >> 16) / (2**16 - 1)
34
35
36
37 class WorldBase:
38
39     def __init__(self, game):
40         self.turn = 0
41         self.things = []
42         self.game = game
43
44     def get_thing(self, id_, create_unfound=True):
45         for thing in self.things:
46             if id_ == thing.id_:
47                 return thing
48         if create_unfound:
49             t = self.game.thing_type(self, id_)
50             self.things += [t]
51             return t
52         return None
53
54     def things_at_pos(self, pos):
55         things = []
56         for t in self.things:
57             if t.position == pos:
58                 things += [t]
59         return things
60
61
62
63 class World(WorldBase):
64
65     def __init__(self, *args, **kwargs):
66         super().__init__(*args, **kwargs)
67         self.player_id = 0
68         self.player_is_alive = True
69         self.maps = {}
70         self.map_size = YX(1,1)
71         self.rand = PRNGod(0)
72
73     @property
74     def player(self):
75         return self.get_thing(self.player_id)
76
77     def new_thing_id(self):
78         if len(self.things) == 0:
79             return 0
80         return self.things[-1].id_ + 1
81
82     def new_map(self, map_pos):
83         self.maps[map_pos] = self.game.map_type(self.map_size)
84
85     def proceed_to_next_player_turn(self):
86         """Run game world turns until player can decide their next step.
87
88         Iterates through all non-player things, on each step
89         furthering them in their tasks (and letting them decide new
90         ones if they finish). The iteration order is: first all things
91         that come after the player in the world things list, then
92         (after incrementing the world turn) all that come before the
93         player; then the player's .proceed() is run, and if it does
94         not finish his task, the loop starts at the beginning. Once
95         the player's task is finished, or the player is dead, the loop
96         breaks.
97
98         """
99         while True:
100             player_i = self.things.index(self.player)
101             for thing in self.things[player_i+1:]:
102                 thing.proceed()
103             self.turn += 1
104             for pos in self.maps[YX(0,0)]:
105                 if self.maps[YX(0,0)][pos] == '.' and \
106                    len(self.things_at_pos((YX(0,0), pos))) == 0 and \
107                    self.rand.random() > 0.999:
108                     self.add_thing_at('food', (YX(0,0), pos))
109             for thing in self.things[:player_i]:
110                 thing.proceed()
111             self.player.proceed(is_AI=False)
112             if self.player.task is None or not self.player_is_alive:
113                 break
114
115     def add_thing_at(self, type_, pos):
116         t = self.game.thing_types[type_](self)
117         t.position = pos
118         self.things += [t]
119         return t
120
121     def make_new(self, yx, seed):
122
123         def add_thing_at_random(type_):
124             while True:
125                 new_pos = (YX(0,0),
126                            YX(self.rand.randint(0, yx.y - 1),
127                               self.rand.randint(0, yx.x - 1)))
128                 if self.maps[new_pos[0]][new_pos[1]] != '.':
129                     continue
130                 if len(self.things_at_pos(new_pos)) > 0:
131                     continue
132                 return self.add_thing_at(type_, new_pos)
133
134         self.things = []
135         self.rand.seed(seed)
136         self.turn = 0
137         self.maps = {}
138         self.map_size = yx
139         self.new_map(YX(0,0))
140         self.new_map(YX(0,1))
141         self.new_map(YX(1,1))
142         self.new_map(YX(1,0))
143         self.new_map(YX(1,-1))
144         self.new_map(YX(0,-1))
145         self.new_map(YX(-1,-1))
146         self.new_map(YX(-1,0))
147         self.new_map(YX(-1,1))
148         for map_pos in self.maps:
149             map_ = self.maps[map_pos]
150             if YX(0,0) == map_pos:
151                 for pos in map_:
152                     map_[pos] = self.rand.choice(('.', '.', '.', '.', 'x'))
153             else:
154                 for pos in map_:
155                     map_[pos] = '~'
156         player = add_thing_at_random('human')
157         self.player_id = player.id_
158         add_thing_at_random('monster')
159         add_thing_at_random('monster')
160         add_thing_at_random('food')
161         add_thing_at_random('food')
162         add_thing_at_random('food')
163         add_thing_at_random('food')
164         return 'success'
165
166
167
168 class Game:
169
170     def __init__(self, game_file_name):
171         self.io = GameIO(game_file_name, self)
172         self.map_type = MapHex
173         self.tasks = {'WAIT': Task_WAIT,
174                       'MOVE': Task_MOVE,
175                       'PICKUP': Task_PICKUP,
176                       'EAT': Task_EAT,
177                       'DROP': Task_DROP}
178         self.commands = {'GEN_WORLD': cmd_GEN_WORLD,
179                          'GET_GAMESTATE': cmd_GET_GAMESTATE,
180                          'SEED': cmd_SEED,
181                          'MAP_SIZE': cmd_MAP_SIZE,
182                          'MAP': cmd_MAP,
183                          'THING_TYPE': cmd_THING_TYPE,
184                          'THING_POS': cmd_THING_POS,
185                          'THING_HEALTH': cmd_THING_HEALTH,
186                          'THING_INVENTORY': cmd_THING_INVENTORY,
187                          'TERRAIN_LINE': cmd_TERRAIN_LINE,
188                          'GET_PICKABLE_ITEMS': cmd_GET_PICKABLE_ITEMS,
189                          'PLAYER_ID': cmd_PLAYER_ID,
190                          'TURN': cmd_TURN,
191                          'SWITCH_PLAYER': cmd_SWITCH_PLAYER,
192                          'SAVE': cmd_SAVE}
193         self.world_type = World
194         self.world = self.world_type(self)
195         self.thing_type = Thing
196         self.thing_types = {'human': ThingHuman,
197                             'monster': ThingMonster,
198                             'food': ThingFood}
199
200     def get_string_options(self, string_option_type):
201         if string_option_type == 'direction':
202             return self.world.maps[YX(0,0)].get_directions()
203         elif string_option_type == 'thingtype':
204             return list(self.thing_types.keys())
205         return None
206
207     def send_gamestate(self, connection_id=None):
208         """Send out game state data relevant to clients."""
209
210         def send_thing(offset, thing):
211             offset_pos = (thing.position[1] - offset)
212             self.io.send('THING_TYPE %s %s' % (thing.id_, thing.type_))
213             self.io.send('THING_POS %s %s' % (thing.id_, offset_pos))
214
215         self.io.send('TURN ' + str(self.world.turn))
216         visible_map = self.world.player.get_visible_map()
217         offset = self.world.player.get_surroundings_offset()
218         self.io.send('VISIBLE_MAP %s %s' % (offset, visible_map.size))
219         for y, line in visible_map.lines():
220             self.io.send('VISIBLE_MAP_LINE %5s %s' % (y, quote(line)))
221         visible_things = self.world.player.get_visible_things()
222         for thing in visible_things:
223             send_thing(offset, thing)
224             if hasattr(thing, 'health'):
225                 self.io.send('THING_HEALTH %s %s' % (thing.id_,
226                                                      thing.health))
227         if len(self.world.player.inventory) > 0:
228             self.io.send('PLAYER_INVENTORY %s' %
229                          ','.join([str(i) for i in self.world.player.inventory]))
230         else:
231             self.io.send('PLAYER_INVENTORY ,')
232         for id_ in self.world.player.inventory:
233             thing = self.world.get_thing(id_)
234             send_thing(offset, thing)
235         self.io.send('GAME_STATE_COMPLETE')
236
237     def proceed(self):
238         """Send turn finish signal, run game world, send new world data.
239
240         First sends 'TURN_FINISHED' message, then runs game world
241         until new player input is needed, then sends game state.
242         """
243         self.io.send('TURN_FINISHED ' + str(self.world.turn))
244         self.world.proceed_to_next_player_turn()
245         msg = str(self.world.player._last_task_result)
246         self.io.send('LAST_PLAYER_TASK_RESULT ' + quote(msg))
247         self.send_gamestate()
248
249     def get_command(self, command_name):
250
251         def partial_with_attrs(f, *args, **kwargs):
252             from functools import partial
253             p = partial(f, *args, **kwargs)
254             p.__dict__.update(f.__dict__)
255             return p
256
257         def cmd_TASK_colon(task_name, game, *args):
258             if not game.world.player_is_alive:
259                 raise GameError('You are dead.')
260             game.world.player.set_task(task_name, args)
261             game.proceed()
262
263         def cmd_SET_TASK_colon(task_name, game, thing_id, todo, *args):
264             t = game.world.get_thing(thing_id, False)
265             if t is None:
266                 raise ArgError('No such Thing.')
267             task_class = game.tasks[task_name]
268             t.task = task_class(t, args)
269             t.task.todo = todo
270
271         def task_prefixed(command_name, task_prefix, task_command,
272                           argtypes_prefix=None):
273             if command_name[:len(task_prefix)] == task_prefix:
274                 task_name = command_name[len(task_prefix):]
275                 if task_name in self.tasks:
276                     f = partial_with_attrs(task_command, task_name, self)
277                     task = self.tasks[task_name]
278                     if argtypes_prefix:
279                         f.argtypes = argtypes_prefix + ' ' + task.argtypes
280                     else:
281                         f.argtypes = task.argtypes
282                     return f
283             return None
284
285         command = task_prefixed(command_name, 'TASK:', cmd_TASK_colon)
286         if command:
287             return command
288         command = task_prefixed(command_name, 'SET_TASK:', cmd_SET_TASK_colon,
289                                 'int:nonneg int:nonneg ')
290         if command:
291             return command
292         if command_name in self.commands:
293             f = partial_with_attrs(self.commands[command_name], self)
294             return f
295         return None