Don't uncarry things on dooring.

[plomrogue2] / plomrogue / game.py

diff --git a/plomrogue/game.py b/plomrogue/game.py
index 10fcb12b19f3c7f644d11eb8376368d99c15028c..b0233b327574dba4ee8fe946395c68066a8e9130 100755 (executable)
--- a/plomrogue/game.py
+++ b/plomrogue/game.py
@@ -117,7 +117,7 @@ class Game(GameBase):
     def __init__(self, save_file, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.changed = True
-        self.changed_fovs = True
+        self.changed_tiles = []
         self.io = GameIO(self, save_file)
         self.tasks = {}
         self.thing_types = {}
@@ -212,7 +212,7 @@ class Game(GameBase):
 
     def remove_thing(self, t):
         self.things.remove(t)
-        self.changed_fovs = True
+        self.record_fov_change(t.position)
 
     def add_thing(self, type_, position, id_=0):
         t_old = None
@@ -223,14 +223,13 @@ class Game(GameBase):
             self.things[self.things.index(t_old)] = t
         else:
             self.things += [t]
-        self.changed_fovs = True
+        self.record_fov_change(t.position)
         return t
 
     def send_gamestate(self, connection_id=None):
         """Send out game state data relevant to clients."""
 
         # TODO: limit to connection_id if provided
-        print('DEBUG send_gamestate')
         self.io.send('TURN ' + str(self.turn))
         from plomrogue.mapping import FovMap
         import multiprocessing
@@ -242,15 +241,19 @@ class Game(GameBase):
             player = self.get_player(c_id)
             if player._fov:
                 continue
-            player.prepare_multiprocessible_fov_stencil() #!
+            player.prepare_multiprocessible_fov_stencil()
             player_fovs += [player._fov]
             player_fov_ids += [player.id_]
-        if len(player_fovs) > 0:
-            print('DEBUG regenerating FOVs')
+        new_fovs = []
+        single_core_until = 8  # since multiprocess has its own overhead
+        if len(player_fovs) > single_core_until:
             pool = multiprocessing.Pool()
-            new_fovs = pool.map(FovMap.init_terrain, [fov for fov in player_fovs])  #!
+            new_fovs = pool.map(FovMap.init_terrain, [fov for fov in player_fovs])
             pool.close()
             pool.join()
+        elif len(player_fovs) <= single_core_until:
+            for fov in player_fovs:
+                new_fovs += [fov.init_terrain()]
         for i in range(len(player_fov_ids)):
             id_ = player_fov_ids[i]
             player = self.get_thing(id_)
@@ -298,6 +301,11 @@ class Game(GameBase):
                                                        quote(annotation)), c_id)
         self.io.send('GAME_STATE_COMPLETE')
 
+    def record_fov_change(self, position):
+        big_yx, little_yx = position
+        self.changed_tiles += [self.map_geometry.undouble_yxyx(big_yx,
+                                                               little_yx)]
+
     def run_tick(self):
         to_delete = []
         for connection_id in self.sessions:
@@ -327,18 +335,34 @@ class Game(GameBase):
                     for connection_id in [c_id for c_id in self.sessions
                                           if self.sessions[c_id]['thing_id'] == t.id_]:
                         self.io.send('PLAY_ERROR ' + quote(str(e)), connection_id)
-        if self.changed_fovs:
-            for t in [t for t in self.things]:
-                t.invalidate_map_view()
         if self.changed:
             self.turn += 1
             # send_gamestate() can be rather expensive, due to among other reasons
-            # re-calculating each player's FOV, so don't send it out too often
+            # re-calculating players' FOVs, so don't send it out too often
             if self.last_send_gamestate < \
                datetime.datetime.now() -self.send_gamestate_interval:
+                if len(self.changed_tiles) > 0:
+                    for t in [t for t in self.things if t.type_ == 'Player']:
+                        fov_radius = 12  # TODO: un-hardcode
+                        absolute_position =\
+                            self.map_geometry.undouble_yxyx(t.position[0],
+                                                            t.position[1])
+                        y_range_start = absolute_position.y - fov_radius
+                        y_range_end = absolute_position.y + fov_radius
+                        x_range_start = absolute_position.x - fov_radius
+                        x_range_end = absolute_position.x + fov_radius
+                        for position in self.changed_tiles:
+                            if position.y < y_range_start\
+                               or position.y > y_range_end:
+                                continue
+                            if position.x < x_range_start\
+                               or position.x > x_range_end:
+                                continue
+                            t.invalidate_map_view()
+                            break
                 self.send_gamestate()
                 self.changed = False
-                self.changed_fovs = False
+                self.changed_tiles = []
                 self.save()
                 self.last_send_gamestate = datetime.datetime.now()