Remove redundant SourcedMap center neutralization.

[plomrogue2] / plomrogue / mapping.py

diff --git a/plomrogue/mapping.py b/plomrogue/mapping.py
index 53e9d29fed1267d51e68dd2c19c2aa5626be6688..7b7ad3c6680e56b0901c40e1ca6ba13c2d9781d1 100644 (file)
--- a/plomrogue/mapping.py
+++ b/plomrogue/mapping.py
@@ -165,7 +165,7 @@ class Map():
 
     def __init__(self, map_geometry):
         self.geometry = map_geometry
-        self.terrain = '.' * self.size_i
+        self.terrain = '.' * self.size_i  # TODO: use Game.get_flatland()?
 
     def __getitem__(self, yx):
         return self.terrain[self.get_position_index(yx)]
@@ -210,28 +210,21 @@ class Map():
 
 class SourcedMap(Map):
 
-    def __init__(self, things, source_maps, source_center, radius, get_map):
+    def __init__(self, block_chars, obstacle_positions, source_maps,
+                 source_center, radius, get_map):
+        self.block_chars = block_chars
         self.radius = radius
         example_map = get_map(YX(0, 0))
         self.source_geometry = example_map.geometry
         size, self.offset, self.center = \
             self.source_geometry.define_segment(source_center, radius)
         self.geometry = self.source_geometry.__class__(size)
-        for yx in self:
-            big_yx, _ = self.source_yxyx(yx)
-            get_map(big_yx)
         self.source_map_segment = ''
-        obstacles = {}
-        for yxyx in [t.position for t in things if t.blocking]:
-            if yxyx == source_center:
-                continue
-            if yxyx[0] not in obstacles:
-                obstacles[yxyx[0]] = []
-            obstacles[yxyx[0]] += [yxyx[1]]
         for yx in self:
             big_yx, little_yx = self.source_yxyx(yx)
-            if big_yx in obstacles and little_yx in obstacles[big_yx]:
-                self.source_map_segment += 'X'
+            get_map(big_yx)
+            if (big_yx, little_yx) in obstacle_positions:
+                self.source_map_segment += self.block_chars[0]
             else:
                 self.source_map_segment += source_maps[big_yx][little_yx]
 
@@ -257,6 +250,12 @@ class SourcedMap(Map):
 class DijkstraMap(SourcedMap):
 
     def __init__(self, *args, **kwargs):
+        # TODO: check potential optimizations:
+        # - do a first pass circling out from the center
+        # - somehow ignore tiles that have the lowest possible value (we can
+        #   compare with a precalculated map for given starting position)
+        # - check if Python offers more efficient data structures to use here
+        # - shorten radius to nearest possible target
         super().__init__(*args, **kwargs)
         self.terrain = [255] * self.size_i
         self[self.center] = 0
@@ -264,7 +263,7 @@ class DijkstraMap(SourcedMap):
         while shrunk:
             shrunk = False
             for i in range(self.size_i):
-                if self.source_map_segment[i] in 'X=':
+                if self.source_map_segment[i] in self.block_chars:
                     continue
                 neighbors = self.geometry.get_neighbors_i(i)
                 for direction in [d for d in neighbors if neighbors[d]]:
@@ -304,7 +303,8 @@ class FovMap(SourcedMap):
         return self
 
     def throws_shadow(self, yx):
-        return self.source_map_segment[self.get_position_index(yx)] == 'X'
+        return self.source_map_segment[self.get_position_index(yx)]\
+            in self.block_chars
 
     def shadow_process(self, yx, distance_to_center, dir_i, dir_progress):
         # Possible optimization: If no shadow_cones yet and self[yx] == '.',
@@ -371,8 +371,7 @@ class FovMap(SourcedMap):
         return mover(pos)
 
     def circle_out(self, yx, f):
-        # Optimization potential: Precalculate movement positions. (How to check
-        # circle_in_map then?)
+        # Optimization potential: Precalculate movement positions.
         # Optimization potential: Precalculate what tiles are shaded by what tile
         # and skip evaluation of already shaded tile. (This only works if tiles
         # shading implies they completely lie in existing shades; otherwise we