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
     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,
-                                     awakeness=self.max_map_awakeness)
+            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]
                         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]
 
                     # Newly inside chunks are regenerated from .stats.
                     if not m.awake:
+                        #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
                                 m.stats[t.type_]['health'] += t.health
                             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)
 
 
 class Map:
 
-    def __init__(self, size=YX(0, 0), init_char = '?', start_indented=True,
-                 awakeness=0):
+    def __init__(self, size=YX(0, 0), init_char = '?', start_indented=True):
         self.size = size
         self.terrain = init_char * self.size_i
         self.start_indented = start_indented
-        self.awake = awakeness  # asleep if zero
-        self.stats = {}
 
     def __getitem__(self, yx):
         return self.terrain[self.get_position_index(yx)]
 
 
 
+class MapChunk(Map):
+    awake = 0  # asleep if zero
+    stats = {}
+
+
+
 class MapGeometry():
 
     def get_directions(self):