X-Git-Url: https://plomlompom.com/repos/foo.html?a=blobdiff_plain;f=plomrogue%2Fmapping.py;h=7b7ad3c6680e56b0901c40e1ca6ba13c2d9781d1;hb=e1240d24097c72f49b0b25f1224588038990645d;hp=5822dada4371170542923c1c63e894e95bc3e1df;hpb=df9a8d0a788b29913dae3eec4ef8113e2d8e9a41;p=plomrogue2

diff --git a/plomrogue/mapping.py b/plomrogue/mapping.py
index 5822dad..7b7ad3c 100644
--- a/plomrogue/mapping.py
+++ b/plomrogue/mapping.py
@@ -21,6 +21,7 @@ class MapGeometry():
     def __init__(self, size):
         self.size = size
         self.neighbors_i = {}
+        self.directions = self.get_directions()
 
     def get_directions(self):
         directions = []
@@ -32,13 +33,13 @@ class MapGeometry():
 
     def get_neighbors_yxyx(self, yxyx):
         neighbors = {}
-        for direction in self.get_directions():
+        for direction in self.directions:
             neighbors[direction] = self.move_yxyx(yxyx, direction)
         return neighbors
 
     def get_neighbors_yx(self, pos):
         neighbors = {}
-        for direction in self.get_directions():
+        for direction in self.directions:
             neighbors[direction] = self.move_yx(pos, direction)
         return neighbors
 
@@ -164,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)]
@@ -209,17 +210,23 @@ class Map():
 
 class SourcedMap(Map):
 
-    def __init__(self, source_maps, source_center, radius, get_map):
-        self.source_maps = source_maps
+    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)
+        self.source_map_segment = ''
         for yx in self:
-            big_yx, _ = self.source_yxyx(yx)
+            big_yx, little_yx = self.source_yxyx(yx)
             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]
 
     def source_yxyx(self, yx):
         absolute_yx = yx + self.offset
@@ -243,18 +250,20 @@ 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
         shrunk = True
-        source_map_segment = ''
-        for yx in self:
-            big_yx, little_yx = self.source_yxyx(yx)
-            source_map_segment += self.source_maps[big_yx][little_yx]
         while shrunk:
             shrunk = False
             for i in range(self.size_i):
-                if source_map_segment[i] == '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]]:
@@ -268,7 +277,7 @@ class DijkstraMap(SourcedMap):
         # for n in self.terrain:
         #     line_to_print += ['%3s' % n]
         #     x += 1
-        #     if x >= self.size.x:
+        #     if x >= self.geometry.size.x:
         #         x = 0
         #         print(' '.join(line_to_print))
         #         line_to_print = []
@@ -284,12 +293,20 @@ class FovMap(SourcedMap):
         self.terrain = '?' * self.size_i
         self[self.center] = '.'
         self.shadow_cones = []
+        #self.circle_out(self.center, self.shadow_process)
+
+    def init_terrain(self):
+        # we outsource this to allow multiprocessing some stab at it,
+        # and return it since multiprocessing does not modify its
+        # processing sources
         self.circle_out(self.center, self.shadow_process)
+        return self
 
-    def throws_shadow(self, big_yx, little_yx):
-        return self.source_maps[big_yx][little_yx] == 'X'
+    def throws_shadow(self, yx):
+        return self.source_map_segment[self.get_position_index(yx)]\
+            in self.block_chars
 
-    def shadow_process(self, yx, source_yxyx, distance_to_center, dir_i, dir_progress):
+    def shadow_process(self, yx, distance_to_center, dir_i, dir_progress):
         # Possible optimization: If no shadow_cones yet and self[yx] == '.',
         # skip all.
         CIRCLE = 360  # Since we'll float anyways, number is actually arbitrary.
@@ -329,7 +346,7 @@ class FovMap(SourcedMap):
             if in_shadow_cone(cone):
                 return
             self[yx] = '.'
-            if self.throws_shadow(*source_yxyx):
+            if self.throws_shadow(yx):
                 unmerged = True
                 while merge_cone(cone):
                     unmerged = False
@@ -354,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
@@ -368,12 +384,12 @@ class FovMap(SourcedMap):
                 for dir_progress in range(distance):
                     direction = self.circle_out_directions[dir_i]
                     yx = self.circle_out_move(yx, direction)
-                    source_yxyx = self.source_yxyx(yx)
-                    f(yx, source_yxyx, distance, dir_i, dir_progress)
+                    f(yx, distance, dir_i, dir_progress)
             distance += 1
 
 
 
+
 class FovMapHex(FovMap):
     circle_out_directions = ('DOWNLEFT', 'LEFT', 'UPLEFT',
                              'UPRIGHT', 'RIGHT', 'DOWNRIGHT')