home · contact · privacy
Register game commands and tasks outside of game module.
[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 MapGeometryHex, MapChunk, 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                               ThingAnimate)
17 import random
18
19
20
21 class PRNGod(random.Random):
22
23     def seed(self, seed):
24         self.prngod_seed = seed
25
26     def getstate(self):
27         return self.prngod_seed
28
29     def setstate(seed):
30         self.seed(seed)
31
32     def random(self):
33         self.prngod_seed = ((self.prngod_seed * 1103515245) + 12345) % 2**32
34         return (self.prngod_seed >> 16) / (2**16 - 1)
35
36
37
38 class GameBase:
39
40     def __init__(self):
41         self.turn = 0
42         self.things = []
43
44     def get_thing(self, id_, create_unfound):
45         # No default for create_unfound because every call to get_thing
46         # should be accompanied by serious consideration whether to use it.
47         for thing in self.things:
48             if id_ == thing.id_:
49                 return thing
50         if create_unfound:
51             t = self.thing_type(self, id_)
52             self.things += [t]
53             return t
54         return None
55
56     def things_at_pos(self, pos):
57         things = []
58         for t in self.things:
59             if t.position == pos:
60                 things += [t]
61         return things
62
63
64
65 class Game(GameBase):
66
67     def __init__(self, game_file_name, *args, **kwargs):
68         super().__init__(*args, **kwargs)
69         self.io = GameIO(game_file_name, self)
70         self.map_size = None
71         self.map_geometry = MapGeometryHex()
72         self.tasks = {'WAIT': Task_WAIT,
73                       'MOVE': Task_MOVE,
74                       'PICKUP': Task_PICKUP,
75                       'EAT': Task_EAT,
76                       'DROP': Task_DROP}
77         self.commands = {'GEN_WORLD': cmd_GEN_WORLD,
78                          'GET_GAMESTATE': cmd_GET_GAMESTATE,
79                          'SEED': cmd_SEED,
80                          'MAP_SIZE': cmd_MAP_SIZE,
81                          'MAP': cmd_MAP,
82                          'THING_TYPE': cmd_THING_TYPE,
83                          'THING_POS': cmd_THING_POS,
84                          'THING_HEALTH': cmd_THING_HEALTH,
85                          'THING_INVENTORY': cmd_THING_INVENTORY,
86                          'TERRAIN_LINE': cmd_TERRAIN_LINE,
87                          'GET_PICKABLE_ITEMS': cmd_GET_PICKABLE_ITEMS,
88                          'PLAYER_ID': cmd_PLAYER_ID,
89                          'TURN': cmd_TURN,
90                          'SWITCH_PLAYER': cmd_SWITCH_PLAYER,
91                          'SAVE': cmd_SAVE}
92         self.thing_type = Thing
93         self.thing_types = {'human': ThingHuman,
94                             'monster': ThingMonster,
95                             'food': ThingFood}
96         self.player_id = 0
97         self.player_is_alive = True
98         self.maps = {}
99         self.max_map_awakeness = 100
100         self.rand = PRNGod(0)
101
102     def get_string_options(self, string_option_type):
103         if string_option_type == 'direction':
104             return self.map_geometry.get_directions()
105         elif string_option_type == 'thingtype':
106             return list(self.thing_types.keys())
107         return None
108
109     def send_gamestate(self, connection_id=None):
110         """Send out game state data relevant to clients."""
111
112         def send_thing(thing):
113             view_pos = self.map_geometry.pos_in_view(thing.position,
114                                                      self.player.view_offset,
115                                                      self.map_size)
116             self.io.send('THING_TYPE %s %s' % (thing.id_, thing.type_))
117             self.io.send('THING_POS %s %s' % (thing.id_, view_pos))
118
119         self.io.send('PLAYER_ID ' + str(self.player_id))
120         self.io.send('TURN ' + str(self.turn))
121         visible_map = self.player.get_visible_map()
122         self.io.send('VISIBLE_MAP %s %s' % (visible_map.size,
123                                             visible_map.start_indented))
124         for y, line in visible_map.lines():
125             self.io.send('VISIBLE_MAP_LINE %5s %s' % (y, quote(line)))
126         visible_things = self.player.get_visible_things()
127         for thing in visible_things:
128             send_thing(thing)
129             if hasattr(thing, 'health'):
130                 self.io.send('THING_HEALTH %s %s' % (thing.id_,
131                                                      thing.health))
132         if len(self.player.inventory) > 0:
133             self.io.send('PLAYER_INVENTORY %s' %
134                          ','.join([str(i) for i in self.player.inventory]))
135         else:
136             self.io.send('PLAYER_INVENTORY ,')
137         for id_ in self.player.inventory:
138             thing = self.get_thing(id_, create_unfound=False)
139             send_thing(thing)
140         self.io.send('GAME_STATE_COMPLETE')
141
142     def proceed(self):
143         """Send turn finish signal, run game world, send new world data.
144
145         First sends 'TURN_FINISHED' message, then runs game world
146         until new player input is needed, then sends game state.
147         """
148         self.io.send('TURN_FINISHED ' + str(self.turn))
149         self.proceed_to_next_player_turn()
150         msg = str(self.player._last_task_result)
151         self.io.send('LAST_PLAYER_TASK_RESULT ' + quote(msg))
152         self.send_gamestate()
153
154     def get_command(self, command_name):
155
156         def partial_with_attrs(f, *args, **kwargs):
157             from functools import partial
158             p = partial(f, *args, **kwargs)
159             p.__dict__.update(f.__dict__)
160             return p
161
162         def cmd_TASK_colon(task_name, game, *args):
163             if not game.player_is_alive:
164                 raise GameError('You are dead.')
165             game.player.set_task(task_name, args)
166             game.proceed()
167
168         def cmd_SET_TASK_colon(task_name, game, thing_id, todo, *args):
169             t = game.get_thing(thing_id, False)
170             if t is None:
171                 raise ArgError('No such Thing.')
172             task_class = game.tasks[task_name]
173             t.task = task_class(t, args)
174             t.task.todo = todo
175
176         def task_prefixed(command_name, task_prefix, task_command,
177                           argtypes_prefix=None):
178             if command_name.startswith(task_prefix):
179                 task_name = command_name[len(task_prefix):]
180                 if task_name in self.tasks:
181                     f = partial_with_attrs(task_command, task_name, self)
182                     task = self.tasks[task_name]
183                     if argtypes_prefix:
184                         f.argtypes = argtypes_prefix + ' ' + task.argtypes
185                     else:
186                         f.argtypes = task.argtypes
187                     return f
188             return None
189
190         command = task_prefixed(command_name, 'TASK:', cmd_TASK_colon)
191         if command:
192             return command
193         command = task_prefixed(command_name, 'SET_TASK:', cmd_SET_TASK_colon,
194                                 'int:nonneg int:nonneg ')
195         if command:
196             return command
197         if command_name in self.commands:
198             f = partial_with_attrs(self.commands[command_name], self)
199             return f
200         return None
201
202     @property
203     def player(self):
204         return self.get_thing(self.player_id, create_unfound=False)
205
206     def new_thing_id(self):
207         if len(self.things) == 0:
208             return 0
209         # DANGEROUS – if anywhere we append a thing to the list of lower
210         # ID than the highest-value ID, this might lead to re-using an
211         # already active ID.  This condition /should/ not be fulfilled
212         # anywhere in the code, but if it does, trouble here is one of
213         # the more obvious indicators that it does – that's why there's
214         # no safeguard here against this.
215         return self.things[-1].id_ + 1
216
217     def get_map(self, map_pos):
218         if not (map_pos in self.maps and
219                 self.maps[map_pos].size == self.map_size):
220             self.maps[map_pos] = MapChunk(self.map_size)
221             self.maps[map_pos].awake = self.max_map_awakeness
222             for pos in self.maps[map_pos]:
223                 self.maps[map_pos][pos] = '.'
224         return self.maps[map_pos]
225
226     def proceed_to_next_player_turn(self):
227         """Run game world turns until player can decide their next step.
228
229         All things and processes inside the player's reality bubble
230         are worked through. Things are furthered in their tasks and,
231         if finished, decide new ones. The iteration order is: first
232         all things that come after the player in the world things
233         list, then (after incrementing the world turn) all that come
234         before the player; then the player's .proceed() is run.
235
236         Next, parts of the game world are put to sleep or woken up
237         based on how close they are to the player's position, or how
238         short ago the player visited them.
239
240         If the player's last task is finished at the end of the loop,
241         it breaks; otherwise it starts again.
242
243         """
244
245         def proceed_world():
246             for thing in self.things[player_i+1:]:
247                 thing.proceed()
248             self.turn += 1
249             for map_pos in self.maps:
250                 if self.maps[map_pos].awake:
251                     for pos in self.maps[map_pos]:
252                         if self.rand.random() > 0.999 and \
253                            self.maps[map_pos][pos] == '.' and \
254                            len(self.things_at_pos((map_pos, pos))) == 0:
255                             self.add_thing_at('food', (map_pos, pos))
256             for thing in self.things[:player_i]:
257                 thing.proceed()
258             self.player.proceed(is_AI=False)
259
260         def reality_bubble():
261
262             def regenerate_chunk_from_map_stats(map_):
263                 import math
264                 max_stat = self.max_map_awakeness
265                 for t_type in map_.stats:
266                     stat = map_.stats[t_type]
267                     to_create = stat['population'] // max_stat
268                     mod_created = int(self.rand.randint(0, max_stat - 1) <
269                                       (stat['population'] % max_stat))
270                     to_create = (stat['population'] // max_stat) + mod_created
271                     if to_create == 0:
272                         continue
273                     average_health = None
274                     if stat['health'] > 0:
275                         average_health = math.ceil(stat['health'] /
276                                                    stat['population'])
277                     for i in range(to_create):
278                         t = self.add_thing_at_random(map_pos, t_type)
279                         if average_health:
280                             t.health = average_health
281                         #if hasattr(t, 'health'):
282                         #    print('DEBUG create', t.type_, t.health)
283
284             for map_pos in self.maps:
285                 m = self.maps[map_pos]
286                 if map_pos in self.player.close_maps:
287
288                     # Newly inside chunks are regenerated from .stats.
289                     if not m.awake:
290                         #print('DEBUG regen stats', map_pos, m.stats)
291                         regenerate_chunk_from_map_stats(m)
292
293                     # Inside chunks are set to max .awake and don't collect
294                     # stats.
295                     m.awake = self.max_map_awakeness
296                     m.stats = {}
297
298                 # Outside chunks grow distant through .awake decremention.
299                 # They collect .stats until they fall asleep – then any things
300                 # inside are disappeared.
301                 elif m.awake > 0:
302                     m.awake -= 1
303                     # We iterate over a list comprehension of self.things,
304                     # since we might delete elements of self.things.
305                     for t in [t for t in self.things]:
306                         if t.position[0] == map_pos:
307                             if not t.type_ in m.stats:
308                                 m.stats[t.type_] = {'population': 0,
309                                                     'health': 0}
310                             m.stats[t.type_]['population'] += 1
311                             if isinstance(t, ThingAnimate):
312                                 m.stats[t.type_]['health'] += t.health
313                             if not m.awake:
314                                 # TODO: Handle inventory.
315                                 del self.things[self.things.index(t)]
316                     #if not m.awake:
317                     #    print('DEBUG sleep stats', map_pos, m.stats)
318
319         while True:
320             player_i = self.things.index(self.player)
321             proceed_world()
322             reality_bubble()
323             if self.player.task is None or not self.player_is_alive:
324                 break
325
326     def add_thing_at(self, type_, pos):
327         t = self.thing_types[type_](self)
328         t.position = pos
329         self.things += [t]
330         return t
331
332     def add_thing_at_random(self, big_yx, type_):
333         while True:
334             new_pos = (big_yx,
335                        YX(self.rand.randint(0, self.map_size.y - 1),
336                           self.rand.randint(0, self.map_size.x - 1)))
337             if self.maps[new_pos[0]][new_pos[1]] != '.':
338                 continue
339             if len(self.things_at_pos(new_pos)) > 0:
340                 continue
341             return self.add_thing_at(type_, new_pos)
342
343     def make_map_chunk(self, big_yx):
344         map_ = self.get_map(big_yx)
345         for pos in map_:
346             map_[pos] = self.rand.choice(('.', '.', '.', '~', 'x'))
347         self.add_thing_at_random(big_yx, 'monster')
348         self.add_thing_at_random(big_yx, 'monster')
349         self.add_thing_at_random(big_yx, 'monster')
350         self.add_thing_at_random(big_yx, 'monster')
351         self.add_thing_at_random(big_yx, 'monster')
352         self.add_thing_at_random(big_yx, 'monster')
353         self.add_thing_at_random(big_yx, 'monster')
354         self.add_thing_at_random(big_yx, 'monster')
355         self.add_thing_at_random(big_yx, 'food')
356         self.add_thing_at_random(big_yx, 'food')
357         self.add_thing_at_random(big_yx, 'food')
358         self.add_thing_at_random(big_yx, 'food')
359
360     def make_new_world(self, size, seed):
361         self.things = []
362         self.rand.seed(seed)
363         self.turn = 0
364         self.maps = {}
365         self.map_size = size
366         self.make_map_chunk(YX(0,0))
367         player = self.add_thing_at_random(YX(0,0), 'human')
368         player.surroundings  # To help initializing reality bubble, see
369                              # comment on ThingAnimate._position_set
370         self.player_id = player.id_
371         return 'success'