X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=server_%2Fgame.py;h=e2a1187c9455ee0dac896605101ec5ec9daa8fb4;hb=b3f0ccf42cae443312ec36309f25a8621ef3e9a8;hp=f596f7bd8ffad7126062f864f90921147be10da2;hpb=6c2138deeea000ebb531203445fa22c1f7a6f0da;p=plomrogue2-experiments

diff --git a/server_/game.py b/server_/game.py
index f596f7b..e2a1187 100644
--- a/server_/game.py
+++ b/server_/game.py
@@ -1,7 +1,6 @@
 import sys
 sys.path.append('../')
 import game_common
-import parser
 
 
 class GameError(Exception):
@@ -186,10 +185,95 @@ class Thing(game_common.Thing):
         return visible_things
 
 
-class Commander(game_common.Commander):
+def fib(n):
+    """Calculate n-th Fibonacci number. Very inefficiently."""
+    if n in (1, 2):
+        return 1
+    else:
+        return fib(n-1) + fib(n-2)
+
+
+class Game(game_common.CommonCommandsMixin):
+
+    def __init__(self, game_file_name):
+        import server_.io
+        self.world = World()
+        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.
+        from multiprocessing import Pool
+        self.pool = Pool()
+        self.pool_result = None
+
+    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))
+        self.io.send('MAP_SIZE ' + stringify_yx(self.world.map_.size))
+        visible_map = self.world.get_player().get_visible_map()
+        for y in range(self.world.map_.size[0]):
+            self.io.send('VISIBLE_MAP_LINE %5s %s' %
+                         (y, self.io.quote(visible_map.get_line(y))))
+        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)))
+
+    def proceed(self):
+        """Send turn finish signal, run game world, send new world data.
+
+        First sends 'TURN_FINISHED' message, then runs game world
+        until new player input is needed, then sends game state.
+        """
+        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))
+        self.send_gamestate()
+
+    def cmd_FIB(self, numbers, connection_id):
+        """Reply with n-th Fibonacci numbers, n taken from tokens[1:].
+
+        Numbers are calculated in parallel as far as possible, using fib().
+        A 'CALCULATING …' message is sent to caller before the result.
+        """
+        self.io.send('CALCULATING …', connection_id)
+        results = self.pool.map(fib, numbers)
+        reply = ' '.join([str(r) for r in results])
+        self.io.send(reply, connection_id)
+    cmd_FIB.argtypes = 'seq:int:nonneg'
+
+    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.
+
+        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:
+            self.pool_result.wait()
+        self.io.send('TURN_FINISHED ' + str(self.world.turn))
+        sleep(1)
+        self.world.turn += 1
+        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
         if direction not in {'UP', 'DOWN', 'RIGHT', 'LEFT'}:
             raise parser.ArgError('Move argument must be one of: '
                                   'UP, DOWN, RIGHT, LEFT')
@@ -208,12 +292,12 @@ class Commander(game_common.Commander):
 
     def cmd_ECHO(self, msg, connection_id):
         """Send msg to caller."""
-        self.send(msg, connection_id)
+        self.io.send(msg, connection_id)
     cmd_ECHO.argtypes = 'string'
 
     def cmd_ALL(self, msg, connection_id):
         """Send msg to all clients."""
-        self.send(msg)
+        self.io.send(msg)
     cmd_ALL.argtypes = 'string'
 
     def cmd_TERRAIN_LINE(self, y, terrain_line):