Re-write mapping system to accomodate infinite map growth.

[plomrogue2] / plomrogue / game.py

diff --git a/plomrogue/game.py b/plomrogue/game.py
index 1ffbf1acfa186f900d96a8252bd5db58dd5fa0a8..3a33660da10dcae09b6a82fe95c24ba252e1668e 100755 (executable)
--- a/plomrogue/game.py
+++ b/plomrogue/game.py
@@ -4,6 +4,7 @@ from plomrogue.errors import GameError, PlayError
 from plomrogue.io import GameIO
 from plomrogue.misc import quote
 from plomrogue.mapping import YX, MapGeometrySquare, Map
 from plomrogue.io import GameIO
 from plomrogue.misc import quote
 from plomrogue.mapping import YX, MapGeometrySquare, Map

+import string

 
 
 
 
 
 


@@ -43,11 +44,25 @@ class Game(GameBase):
         self.tasks = {}
         self.thing_types = {}
         self.sessions = {}
         self.tasks = {}
         self.thing_types = {}
         self.sessions = {}

-        self.map = Map(self.map_geometry.size)
-        self.map_control = Map(self.map_geometry.size)
+        self.maps = {}
+        self.map_controls = {}

         self.map_control_passwords = {}
         self.annotations = {}
         self.portals = {}
         self.map_control_passwords = {}
         self.annotations = {}
         self.portals = {}

+        self.player_chars = string.digits + string.ascii_letters
+        self.player_char_i = -1
+        self.terrains = {
+            '.': 'floor',
+            'X': 'wall',
+            '=': 'window',
+            '#': 'bed',
+            'T': 'desk',
+            '8': 'cupboard',
+            '[': 'glass door',
+            'o': 'sink',
+            'O': 'toilet'
+        }
+        self.new_world(self.map_geometry)

         if os.path.exists(self.io.save_file):
             if not os.path.isfile(self.io.save_file):
                 raise GameError('save file path refers to non-file')
         if os.path.exists(self.io.save_file):
             if not os.path.isfile(self.io.save_file):
                 raise GameError('save file path refers to non-file')


@@ -67,8 +82,9 @@ class Game(GameBase):
                 print("FILE INPUT LINE %5s: %s" % (i, line), end='')
                 self.io.handle_input(line, god_mode=True)
 
                 print("FILE INPUT LINE %5s: %s" % (i, line), end='')
                 self.io.handle_input(line, god_mode=True)
 

-    def can_do_tile_with_pw(self, yx, pw):
-        tile_class = self.map_control[yx]
+    def can_do_tile_with_pw(self, big_yx, little_yx, pw):
+        map_control = self.get_map(big_yx)
+        tile_class = map_control[little_yx]

         if tile_class in self.map_control_passwords:
             tile_pw = self.map_control_passwords[tile_class]
             if pw != tile_pw:
         if tile_class in self.map_control_passwords:
             tile_pw = self.map_control_passwords[tile_class]
             if pw != tile_pw:


@@ -76,7 +92,6 @@ class Game(GameBase):
         return True
 
     def get_string_options(self, string_option_type):
         return True
 
     def get_string_options(self, string_option_type):

-        import string

         if string_option_type == 'direction':
             return self.map_geometry.get_directions()
         elif string_option_type == 'char':
         if string_option_type == 'direction':
             return self.map_geometry.get_directions()
         elif string_option_type == 'char':


@@ -97,22 +112,27 @@ class Game(GameBase):
         self.io.send('TURN ' + str(self.turn))
         for c_id in self.sessions:
             player = self.get_thing(self.sessions[c_id])
         self.io.send('TURN ' + str(self.turn))
         for c_id in self.sessions:
             player = self.get_thing(self.sessions[c_id])

-            visible_terrain = player.fov_stencil_map(self.map)
+            visible_terrain = player.fov_stencil_map()

             self.io.send('FOV %s' % quote(player.fov_stencil.terrain), c_id)
             self.io.send('MAP %s %s %s' % (self.get_map_geometry_shape(),
             self.io.send('FOV %s' % quote(player.fov_stencil.terrain), c_id)
             self.io.send('MAP %s %s %s' % (self.get_map_geometry_shape(),

-                                           self.map_geometry.size,
+                                           player.fov_stencil.geometry.size,

                                            quote(visible_terrain)), c_id)
                                            quote(visible_terrain)), c_id)

-            visible_control = player.fov_stencil_map(self.map_control)
+            visible_control = player.fov_stencil_map('control')

             self.io.send('MAP_CONTROL %s' % quote(visible_control), c_id)
             self.io.send('MAP_CONTROL %s' % quote(visible_control), c_id)

-            for t in [t for t in self.things
-                      if player.fov_stencil[t.position] == '.']:
-                self.io.send('THING %s %s %s' % (t.position, t.type_, t.id_), c_id)
-                if hasattr(t, 'nickname'):
-                    self.io.send('THING_NAME %s %s' % (t.id_,
-                                                       quote(t.nickname)), c_id)
-            for yx in [yx for yx in self.portals
-                       if player.fov_stencil[yx] == '.']:
-                self.io.send('PORTAL %s %s' % (yx, quote(self.portals[yx])), c_id)
+            for t in [t for t in self.things if player.fov_test(*t.position)]:
+                target_yx = player.fov_stencil.target_yx(*t.position)
+                self.io.send('THING %s %s %s' % (target_yx, t.type_, t.id_), c_id)
+                if hasattr(t, 'name'):
+                    self.io.send('THING_NAME %s %s' % (t.id_, quote(t.name)), c_id)
+                if hasattr(t, 'player_char'):
+                    self.io.send('THING_CHAR %s %s' % (t.id_,
+                                                       quote(t.player_char)), c_id)
+            for big_yx in self.portals:
+                for little_yx in [little_yx for little_yx in self.portals[big_yx]
+                                  if player.fov_test(big_yx, little_yx)]:
+                    target_yx = player.fov_stencil.target_yx(big_yx, little_yx)
+                    portal = self.portals[big_yx][little_yx]
+                    self.io.send('PORTAL %s %s' % (target_yx, quote(portal)), c_id)

         self.io.send('GAME_STATE_COMPLETE')
 
     def run_tick(self):
         self.io.send('GAME_STATE_COMPLETE')
 
     def run_tick(self):


@@ -125,8 +145,8 @@ class Game(GameBase):
                     break
             if not connection_id_found:
                 t = self.get_thing(self.sessions[connection_id])
                     break
             if not connection_id_found:
                 t = self.get_thing(self.sessions[connection_id])

-                if hasattr(t, 'nickname'):
-                    self.io.send('CHAT ' + quote(t.nickname + ' left the map.'))
+                if hasattr(t, 'name'):
+                    self.io.send('CHAT ' + quote(t.name + ' left the map.'))

                 self.things.remove(t)
                 to_delete += [connection_id]
         for connection_id in to_delete:
                 self.things.remove(t)
                 to_delete += [connection_id]
         for connection_id in to_delete:


@@ -187,6 +207,12 @@ class Game(GameBase):
             return 1
         return max([t.id_ for t in self.things]) + 1
 
             return 1
         return max([t.id_ for t in self.things]) + 1
 

+    def get_next_player_char(self):
+        self.player_char_i += 1
+        if self.player_char_i >= len(self.player_chars):
+            self.player_char_i = 0
+        return self.player_chars[self.player_char_i]
+

     def save(self):
 
       def write(f, msg):
     def save(self):
 
       def write(f, msg):


@@ -197,22 +223,40 @@ class Game(GameBase):
           write(f, 'TURN %s' % self.turn)
           map_geometry_shape = self.get_map_geometry_shape()
           write(f, 'MAP %s %s' % (map_geometry_shape, self.map_geometry.size,))
           write(f, 'TURN %s' % self.turn)
           map_geometry_shape = self.get_map_geometry_shape()
           write(f, 'MAP %s %s' % (map_geometry_shape, self.map_geometry.size,))

-          for y, line in self.map.lines():
-              write(f, 'MAP_LINE %5s %s' % (y, quote(line)))
-          for yx in self.annotations:
-              write(f, 'GOD_ANNOTATE %s %s' % (yx, quote(self.annotations[yx])))
-          for yx in self.portals:
-              write(f, 'GOD_PORTAL %s %s' % (yx, quote(self.portals[yx])))
-          for y, line in self.map_control.lines():
-              write(f, 'MAP_CONTROL_LINE %5s %s' % (y, quote(line)))
+          for yx in self.maps:
+              for y, line in self.maps[yx].lines():
+                  write(f, 'MAP_LINE %s %5s %s' % (yx, y, quote(line)))
+          for big_yx in self.annotations:
+              for little_yx in self.annotations[big_yx]:
+                  write(f, 'GOD_ANNOTATE %s %s %s' %
+                        (big_yx, little_yx, quote(self.annotations[big_yx][little_yx])))
+          for big_yx in self.portals:
+              for little_yx in self.portals[big_yx]:
+                  write(f, 'GOD_PORTAL %s %s %s' % (big_yx, little_yx,
+                                                    quote(self.portals[big_yx][little_yx])))
+          for yx in self.map_controls:
+              for y, line in self.map_controls[yx].lines():
+                  write(f, 'MAP_CONTROL_LINE %s %5s %s' % (yx, y, quote(line)))

           for tile_class in self.map_control_passwords:
               write(f, 'MAP_CONTROL_PW %s %s' % (tile_class,
                                                  self.map_control_passwords[tile_class]))
           for t in [t for t in self.things if not t.type_ == 'Player']:
           for tile_class in self.map_control_passwords:
               write(f, 'MAP_CONTROL_PW %s %s' % (tile_class,
                                                  self.map_control_passwords[tile_class]))
           for t in [t for t in self.things if not t.type_ == 'Player']:

-              write(f, 'THING %s %s %s' % (t.position, t.type_, t.id_))
+              write(f, 'THING %s %s %s %s' % (t.position[0],
+                                              t.position[1], t.type_, t.id_))
+              if hasattr(t, 'name'):
+                  write(f, 'THING_NAME %s %s' % (t.id_, quote(t.name)))
+
+    def get_map(self, big_yx, type_='normal'):
+        if type_ == 'normal':
+            maps = self.maps
+        elif type_ == 'control':
+            maps = self.map_controls
+        if not big_yx in maps:
+            maps[big_yx] = Map(self.map_geometry)
+        return maps[big_yx]

 
     def new_world(self, map_geometry):
         self.map_geometry = map_geometry
 
     def new_world(self, map_geometry):
         self.map_geometry = map_geometry

-        self.map = Map(self.map_geometry.size)
-        self.map_control = Map(self.map_geometry.size)
+        self.maps[YX(0,0)] = Map(self.map_geometry)
+        self.map_controls[YX(0,0)] = Map(self.map_geometry)

         self.annotations = {}
         self.annotations = {}