home · contact · privacy
Add FLATTEN_SURROUNDINGS task.
[plomrogue2-experiments] / server_ / game.py
1 import sys
2 sys.path.append('../')
3 import game_common
4 import server_.map_
5 import server_.io
6 import server_.tasks
7 from server_.game_error import GameError
8 from parser import ArgError
9
10
11 class World(game_common.World):
12
13     def __init__(self, game):
14         super().__init__()
15         self.game = game
16         self.player_id = 0
17         # use extended local classes
18         self.Thing = Thing
19
20     def proceed_to_next_player_turn(self):
21         """Run game world turns until player can decide their next step.
22
23         Iterates through all non-player things, on each step
24         furthering them in their tasks (and letting them decide new
25         ones if they finish). The iteration order is: first all things
26         that come after the player in the world things list, then
27         (after incrementing the world turn) all that come before the
28         player; then the player's .proceed() is run, and if it does
29         not finish his task, the loop starts at the beginning. Once
30         the player's task is finished, the loop breaks.
31         """
32         while True:
33             player = self.get_player()
34             player_i = self.things.index(player)
35             for thing in self.things[player_i+1:]:
36                 thing.proceed()
37             self.turn += 1
38             for thing in self.things[:player_i]:
39                 thing.proceed()
40             player.proceed(is_AI=False)
41             if player.task is None:
42                 break
43
44     def get_player(self):
45         return self.get_thing(self.player_id)
46
47     def make_new(self, geometry, yx, seed):
48         import random
49         random.seed(seed)
50         self.turn = 0
51         self.new_map(geometry, yx)
52         for pos in self.map_:
53             if 0 in pos or (yx[0] - 1) == pos[0] or (yx[1] - 1) == pos[1]:
54                 self.map_[pos] = '#'
55                 continue
56             self.map_[pos] = random.choice(('.', '.', '.', '.', 'x'))
57         player = self.Thing(self, 0)
58         player.type_ = 'human'
59         player.position = [random.randint(0, yx[0] -1),
60                            random.randint(0, yx[1] - 1)]
61         npc = self.Thing(self, 1)
62         npc.type_ = 'monster'
63         npc.position = [random.randint(0, yx[0] -1),
64                         random.randint(0, yx[1] -1)]
65         self.things = [player, npc]
66
67
68         return 'success'
69
70
71
72 class Thing(game_common.Thing):
73
74     def __init__(self, *args, **kwargs):
75         super().__init__(*args, **kwargs)
76         self.task = self.world.game.task_manager.get_task_class('WAIT')(self)
77         self._last_task_result = None
78         self._stencil = None
79
80     def move_towards_target(self, target):
81         dijkstra_map = type(self.world.map_)(self.world.map_.size)
82         n_max = 256
83         dijkstra_map.terrain = [n_max for i in range(dijkstra_map.size_i)]
84         dijkstra_map[target] = 0
85         shrunk = True
86         visible_map = self.get_visible_map()
87         while shrunk:
88             shrunk = False
89             for pos in dijkstra_map:
90                 if visible_map[pos] != '.':
91                     continue
92                 neighbors = dijkstra_map.get_neighbors(tuple(pos))
93                 for direction in neighbors:
94                     yx = neighbors[direction]
95                     if yx is not None and dijkstra_map[yx] < dijkstra_map[pos] - 1:
96                         dijkstra_map[pos] = dijkstra_map[yx] + 1
97                         shrunk = True
98         #with open('log', 'a') as f:
99         #    f.write('---------------------------------\n')
100         #    for y, line in dijkstra_map.lines():
101         #        for val in line:
102         #            if val < 10:
103         #                f.write(str(val))
104         #            elif val == 256:
105         #                f.write('x')
106         #            else:
107         #                f.write('~')
108         #        f.write('\n')
109         neighbors = dijkstra_map.get_neighbors(tuple(self.position))
110         n = n_max
111         #print('DEBUG', self.position, neighbors)
112         #dirs = dijkstra_map.get_directions()
113         #print('DEBUG dirs', dirs)
114         #print('DEBUG neighbors', neighbors)
115         #debug_scores = []
116         #for pos in neighbors:
117         #    if pos is None:
118         #        debug_scores += [9000]
119         #    else:
120         #        debug_scores += [dijkstra_map[pos]]
121         #print('DEBUG debug_scores', debug_scores)
122         target_direction = None
123         for direction in neighbors:
124             yx = neighbors[direction]
125             if yx is not None:
126                 n_new = dijkstra_map[yx]
127                 if n_new < n:
128                     n = n_new
129                     target_direction = direction
130         #print('DEBUG result', direction)
131         if target_direction:
132             self.set_task('MOVE', (target_direction,))
133
134     def decide_task(self):
135         # TODO: Check if monster can follow player too well (even when they should lose them)
136         visible_things = self.get_visible_things()
137         target = None
138         for t in visible_things:
139             if t.type_ == 'human':
140                 target = t.position
141                 break
142         if target is not None:
143             try:
144                 self.move_towards_target(target)
145                 return
146             except GameError:
147                 pass
148         self.set_task('WAIT')
149
150
151     def set_task(self, task_name, args=()):
152         task_class = self.world.game.task_manager.get_task_class(task_name)
153         self.task = task_class(self, args)
154         self.task.check()  # will throw GameError if necessary
155
156     def proceed(self, is_AI=True):
157         """Further the thing in its tasks.
158
159         Decrements .task.todo; if it thus falls to <= 0, enacts method
160         whose name is 'task_' + self.task.name and sets .task =
161         None. If is_AI, calls .decide_task to decide a self.task.
162
163         Before doing anything, ensures an empty map visibility stencil
164         and checks that task is still possible, and aborts it
165         otherwise (for AI things, decides a new task).
166
167         """
168         self._stencil = None
169         try:
170             self.task.check()
171         except GameError as e:
172             self.task = None
173             self._last_task_result = e
174             if is_AI:
175                 try:
176                     self.decide_task()
177                 except GameError:
178                     self.set_task('WAIT')
179             return
180         self.task.todo -= 1
181         if self.task.todo <= 0:
182             self._last_task_result = self.task.do()
183             self.task = None
184         if is_AI and self.task is None:
185             try:
186                 self.decide_task()
187             except GameError:
188                 self.set_task('WAIT')
189
190     def get_stencil(self):
191         if self._stencil is not None:
192             return self._stencil
193         self._stencil = self.world.map_.get_fov_map(self.position)
194         return self._stencil
195
196     def get_visible_map(self):
197         stencil = self.get_stencil()
198         m = self.world.map_.new_from_shape(' ')
199         for pos in m:
200             if stencil[pos] == '.':
201                 m[pos] = self.world.map_[pos]
202         return m
203
204     def get_visible_things(self):
205         stencil = self.get_stencil()
206         visible_things = []
207         for thing in self.world.things:
208             if stencil[thing.position] == '.':
209                 visible_things += [thing]
210         return visible_things
211
212
213 def fib(n):
214     """Calculate n-th Fibonacci number. Very inefficiently."""
215     if n in (1, 2):
216         return 1
217     else:
218         return fib(n-1) + fib(n-2)
219
220
221 class Game(game_common.CommonCommandsMixin):
222
223     def __init__(self, game_file_name):
224         self.map_manager = server_.map_.map_manager
225         self.task_manager = server_.tasks.task_manager
226         self.world = World(self)
227         self.io = server_.io.GameIO(game_file_name, self)
228         # self.pool and self.pool_result are currently only needed by the FIB
229         # command and the demo of a parallelized game loop in cmd_inc_p.
230         from multiprocessing import Pool
231         self.pool = Pool()
232         self.pool_result = None
233
234     def send_gamestate(self, connection_id=None):
235         """Send out game state data relevant to clients."""
236
237         self.io.send('TURN ' + str(self.world.turn))
238         self.io.send('MAP ' + self.world.map_.geometry +\
239                      ' ' + server_.io.stringify_yx(self.world.map_.size))
240         visible_map = self.world.get_player().get_visible_map()
241         for y, line in visible_map.lines():
242             self.io.send('VISIBLE_MAP_LINE %5s %s' % (y, server_.io.quote(line)))
243         visible_things = self.world.get_player().get_visible_things()
244         for thing in visible_things:
245             self.io.send('THING_TYPE %s %s' % (thing.id_, thing.type_))
246             self.io.send('THING_POS %s %s' % (thing.id_,
247                                               server_.io.stringify_yx(thing.position)))
248         player = self.world.get_player()
249         self.io.send('PLAYER_POS %s' % (server_.io.stringify_yx(player.position)))
250         self.io.send('GAME_STATE_COMPLETE')
251
252     def proceed(self):
253         """Send turn finish signal, run game world, send new world data.
254
255         First sends 'TURN_FINISHED' message, then runs game world
256         until new player input is needed, then sends game state.
257         """
258         self.io.send('TURN_FINISHED ' + str(self.world.turn))
259         self.world.proceed_to_next_player_turn()
260         msg = str(self.world.get_player()._last_task_result)
261         self.io.send('LAST_PLAYER_TASK_RESULT ' + server_.io.quote(msg))
262         self.send_gamestate()
263
264     def cmd_FIB(self, numbers, connection_id):
265         """Reply with n-th Fibonacci numbers, n taken from tokens[1:].
266
267         Numbers are calculated in parallel as far as possible, using fib().
268         A 'CALCULATING …' message is sent to caller before the result.
269         """
270         self.io.send('CALCULATING …', connection_id)
271         results = self.pool.map(fib, numbers)
272         reply = ' '.join([str(r) for r in results])
273         self.io.send(reply, connection_id)
274     cmd_FIB.argtypes = 'seq:int:nonneg'
275
276     def cmd_INC_P(self, connection_id):
277         """Increment world.turn, send game turn data to everyone.
278
279         To simulate game processing waiting times, a one second delay
280         between TURN_FINISHED and TURN occurs; after TURN, some
281         expensive calculations are started as pool processes that need
282         to be finished until a further INC finishes the turn.
283
284         This is just a demo structure for how the game loop could work
285         when parallelized. One might imagine a two-step game turn,
286         with a non-action step determining actor tasks (the AI
287         determinations would take the place of the fib calculations
288         here), and an action step wherein these tasks are performed
289         (where now sleep(1) is).
290
291         """
292         from time import sleep
293         if self.pool_result is not None:
294             self.pool_result.wait()
295         self.io.send('TURN_FINISHED ' + str(self.world.turn))
296         sleep(1)
297         self.world.turn += 1
298         self.send_gamestate()
299         self.pool_result = self.pool.map_async(fib, (35, 35))
300
301     def cmd_SWITCH_PLAYER(self):
302         player = self.world.get_player()
303         player.set_task('WAIT')
304         thing_ids = [t.id_ for t in self.world.things]
305         player_index = thing_ids.index(player.id_)
306         if player_index == len(thing_ids) - 1:
307             self.world.player_id = thing_ids[0]
308         else:
309             self.world.player_id = thing_ids[player_index + 1]
310         self.proceed()
311
312     def cmd_GET_GAMESTATE(self, connection_id):
313         """Send game state to caller."""
314         self.send_gamestate(connection_id)
315
316     def cmd_ECHO(self, msg, connection_id):
317         """Send msg to caller."""
318         self.io.send(msg, connection_id)
319     cmd_ECHO.argtypes = 'string'
320
321     def cmd_ALL(self, msg, connection_id):
322         """Send msg to all clients."""
323         self.io.send(msg)
324     cmd_ALL.argtypes = 'string'
325
326     def cmd_TERRAIN_LINE(self, y, terrain_line):
327         self.world.map_.set_line(y, terrain_line)
328     cmd_TERRAIN_LINE.argtypes = 'int:nonneg string'
329
330     def cmd_GEN_WORLD(self, geometry, yx, seed):
331         self.world.make_new(geometry, yx, seed)
332     cmd_GEN_WORLD.argtypes = 'string:geometry yx_tuple:pos string'
333
334     def get_command_signature(self, command_name):
335         from functools import partial
336
337         def cmd_TASK_colon(task_name, *args):
338             self.world.get_player().set_task(task_name, args)
339             self.proceed()
340
341         def cmd_SET_TASK_colon(task_name, thing_id, todo, *args):
342             t = self.world.get_thing(thing_id, False)
343             if t is None:
344                 raiseArgError('No such Thing.')
345             task_class = self.task_manager.get_task_class(task_name)
346             t.task = task_class(t, args)
347             t.task.todo = todo
348
349         def task_prefixed(command_name, task_prefix, task_command,
350                           argtypes_prefix=''):
351             func = None
352             argtypes = ''
353             if command_name[:len(task_prefix)] == task_prefix:
354                 task_name = command_name[len(task_prefix):]
355                 task_manager_reply = self.task_manager.get_task_class(task_name)
356                 if task_manager_reply is not None:
357                     func = partial(task_command, task_name)
358                     task_class = task_manager_reply
359                     argtypes = task_class.argtypes
360             if func is not None:
361                 return func, argtypes_prefix + argtypes
362             return None, argtypes
363
364         func, argtypes = task_prefixed(command_name, 'TASK:', cmd_TASK_colon)
365         if func:
366             return func, argtypes
367         func, argtypes = task_prefixed(command_name, 'SET_TASK:',
368                                          cmd_SET_TASK_colon,
369                                          'int:nonneg int:nonneg ')
370         if func:
371             return func, argtypes
372         func_candidate = 'cmd_' + command_name
373         if hasattr(self, func_candidate):
374             func = getattr(self, func_candidate)
375             if hasattr(func, 'argtypes'):
376                 argtypes = func.argtypes
377         return func, argtypes
378
379     def get_string_options(self, string_option_type):
380         if string_option_type == 'geometry':
381             return self.map_manager.get_map_geometries()
382         elif string_option_type == 'direction':
383             return self.world.map_.get_directions()
384         return None
385
386     def cmd_PLAYER_ID(self, id_):
387         # TODO: test whether valid thing ID
388         self.world.player_id = id_
389     cmd_PLAYER_ID.argtypes = 'int:nonneg'
390
391     def cmd_TURN(self, n):
392         self.world.turn = n
393     cmd_TURN.argtypes = 'int:nonneg'
394
395     def cmd_SAVE(self):
396
397         def write(f, msg):
398             f.write(msg + '\n')
399
400         save_file_name = self.io.game_file_name + '.save'
401         with open(save_file_name, 'w') as f:
402             write(f, 'TURN %s' % self.world.turn)
403             write(f, 'MAP ' + self.world.map_.geometry + ' ' + server_.io.stringify_yx(self.world.map_.size))
404             for y, line in self.world.map_.lines():
405                 write(f, 'TERRAIN_LINE %5s %s' % (y, server_.io.quote(line)))
406             for thing in self.world.things:
407                 write(f, 'THING_TYPE %s %s' % (thing.id_, thing.type_))
408                 write(f, 'THING_POS %s %s' % (thing.id_,
409                                               server_.io.stringify_yx(thing.position)))
410                 task = thing.task
411                 if task is not None:
412                     task_args = task.get_args_string()
413                     write(f, 'SET_TASK:%s %s %s %s' % (task.name, thing.id_,
414                                                        task.todo, task_args))
415             write(f, 'PLAYER_ID %s' % self.world.player_id)
416     cmd_SAVE.dont_save = True