Decouple awakeness/sleep stats from Map to MapChunk.

[plomrogue2-experiments] / new / plomrogue / game.py

diff --git a/new/plomrogue/game.py b/new/plomrogue/game.py
index 0e1ff9aecc6b22acfc0eafc230a0b6d3a19f2ca8..d20713cd61fa219d387808ef3c2e9bdbd8ac4fff 100755 (executable)
--- a/new/plomrogue/game.py
+++ b/new/plomrogue/game.py
@@ -8,7 +8,7 @@ from plomrogue.commands import (cmd_GEN_WORLD, cmd_GET_GAMESTATE,
                                 cmd_GET_PICKABLE_ITEMS, cmd_MAP_SIZE,
                                 cmd_TERRAIN_LINE, cmd_PLAYER_ID,
                                 cmd_TURN, cmd_SWITCH_PLAYER, cmd_SAVE)
-from plomrogue.mapping import MapGeometryHex, Map, YX
+from plomrogue.mapping import MapGeometryHex, MapChunk, YX
 from plomrogue.parser import Parser
 from plomrogue.io import GameIO
 from plomrogue.misc import quote
@@ -94,6 +94,7 @@ class Game(GameBase):
         self.player_id = 0
         self.player_is_alive = True
         self.maps = {}
+        self.max_map_awakeness = 100
         self.rand = PRNGod(0)
 
     def get_string_options(self, string_option_type):
@@ -208,7 +209,8 @@ class Game(GameBase):
     def get_map(self, map_pos):
         if not (map_pos in self.maps and
                 self.maps[map_pos].size == self.map_size):
-            self.maps[map_pos] = Map(self.map_size)
+            self.maps[map_pos] = MapChunk(self.map_size)
+            self.maps[map_pos].awake = self.max_map_awakeness
             for pos in self.maps[map_pos]:
                 self.maps[map_pos][pos] = '.'
         return self.maps[map_pos]
@@ -248,32 +250,41 @@ class Game(GameBase):
             self.player.proceed(is_AI=False)
 
         def reality_bubble():
-            import math
+
+            def regenerate_chunk_from_map_stats(map_):
+                import math
+                max_stat = self.max_map_awakeness
+                for t_type in map_.stats:
+                    stat = map_.stats[t_type]
+                    to_create = stat['population'] // max_stat
+                    mod_created = int(self.rand.randint(0, max_stat - 1) <
+                                      (stat['population'] % max_stat))
+                    to_create = (stat['population'] // max_stat) + mod_created
+                    if to_create == 0:
+                        continue
+                    average_health = None
+                    if stat['health'] > 0:
+                        average_health = math.ceil(stat['health'] /
+                                                   stat['population'])
+                    for i in range(to_create):
+                        t = self.add_thing_at_random(map_pos, t_type)
+                        if average_health:
+                            t.health = average_health
+                        #if hasattr(t, 'health'):
+                        #    print('DEBUG create', t.type_, t.health)
+
             for map_pos in self.maps:
                 m = self.maps[map_pos]
                 if map_pos in self.player.close_maps:
 
                     # Newly inside chunks are regenerated from .stats.
                     if not m.awake:
-                        for t_type in m.stats:
-                            stat = m.stats[t_type]
-                            to_create = stat['population'] // 100
-                            to_create = stat['population'] // 100 +\
-                                int(self.rand.randint(0, 99) < (stat['population'] % 100))
-                            if to_create == 0:
-                                continue
-                            average_health = None
-                            if stat['health'] > 0:
-                                average_health = math.ceil(stat['health'] /
-                                                           stat['population'])
-                            for i in range(to_create):
-                                t = self.add_thing_at_random(map_pos, t_type)
-                                if average_health:
-                                    t.health = average_health
+                        #print('DEBUG regen stats', map_pos, m.stats)
+                        regenerate_chunk_from_map_stats(m)
 
                     # Inside chunks are set to max .awake and don't collect
                     # stats.
-                    m.awake = 100
+                    m.awake = self.max_map_awakeness
                     m.stats = {}
 
                 # Outside chunks grow distant through .awake decremention.
@@ -289,9 +300,10 @@ class Game(GameBase):
                             m.stats[t.type_]['population'] += 1
                             if isinstance(t, ThingAnimate):
                                 m.stats[t.type_]['health'] += t.health
-                                if not m.awake:
                             if not m.awake:
                                 del self.things[self.things.index(t)]
+                    #if not m.awake:
+                    #    print('DEBUG sleep stats', map_pos, m.stats)
 
         while True:
             player_i = self.things.index(self.player)