X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=plomrogue%2Fmapping.py;h=707111263d884b21508ba536fc02b95e2af66677;hb=64cf00e418112f70163a5b24ccad8247a88abfd9;hp=5822dada4371170542923c1c63e894e95bc3e1df;hpb=df9a8d0a788b29913dae3eec4ef8113e2d8e9a41;p=plomrogue2 diff --git a/plomrogue/mapping.py b/plomrogue/mapping.py index 5822dad..7071112 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 @@ -84,6 +85,10 @@ class MapGeometry(): x = big_yx.x * self.size.x + little_yx.x return YX(y, x) + def basic_circle_out_move(self, position, direction): + mover = getattr(self, 'move__' + direction) + return mover(position) + class MapGeometryWithLeftRightMoves(MapGeometry): @@ -97,10 +102,12 @@ class MapGeometryWithLeftRightMoves(MapGeometry): class MapGeometrySquare(MapGeometryWithLeftRightMoves): + circle_out_directions = (('DOWN', 'LEFT'), ('LEFT', 'UP'), + ('UP', 'RIGHT'), ('RIGHT', 'DOWN')) - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self.fov_map_class = FovMapSquare + def circle_out_move(self, yx, direction): + yx = self.basic_circle_out_move(yx, direction[0]) + return self.basic_circle_out_move(yx, direction[1]) def define_segment(self, source_center, radius): source_center = self.undouble_yxyx(*source_center) @@ -117,10 +124,11 @@ class MapGeometrySquare(MapGeometryWithLeftRightMoves): class MapGeometryHex(MapGeometryWithLeftRightMoves): + circle_out_directions = ('DOWNLEFT', 'LEFT', 'UPLEFT', + 'UPRIGHT', 'RIGHT', 'DOWNRIGHT') - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self.fov_map_class = FovMapHex + def circle_out_move(self, yx, direction): + return self.basic_circle_out_move(yx, direction) def define_segment(self, source_center, radius): source_center = self.undouble_yxyx(*source_center) @@ -164,7 +172,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 +217,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 @@ -242,33 +256,59 @@ class SourcedMap(Map): class DijkstraMap(SourcedMap): - def __init__(self, *args, **kwargs): + def __init__(self, potential_targets, *args, **kwargs): + # TODO: check potential optimizations: + # - 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 super().__init__(*args, **kwargs) self.terrain = [255] * self.size_i self[self.center] = 0 + targets = [] + for target_yxyx in potential_targets: + target = self.target_yx(*target_yxyx) + if target == self.center: + continue + if self.inside(target): + targets += [target] + + def work_tile(position_i): + shrunk_test = False + if self.source_map_segment[position_i] in self.block_chars: + return shrunk_test + neighbors = self.geometry.get_neighbors_i(position_i) + for direction in [d for d in neighbors if neighbors[d]]: + j = neighbors[direction] + if self.terrain[j] < self.terrain[position_i] - 1: + self.terrain[position_i] = self.terrain[j] + 1 + shrunk_test = True + return shrunk_test + + # TODO: refactor with FovMap.circle_out() 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: + while shrunk and len(targets) > 0: shrunk = False - for i in range(self.size_i): - if source_map_segment[i] == 'X': - continue - neighbors = self.geometry.get_neighbors_i(i) - for direction in [d for d in neighbors if neighbors[d]]: - j = neighbors[direction] - if self.terrain[j] < self.terrain[i] - 1: - self.terrain[i] = self.terrain[j] + 1 - shrunk = True + yx = self.center + distance = 1 + while distance <= self.radius and len(targets) > 0: + yx = self.geometry.basic_circle_out_move(yx, 'RIGHT') + for dir_i in range(len(self.geometry.circle_out_directions)): + for dir_progress in range(distance): + direction = self.geometry.circle_out_directions[dir_i] + yx = self.geometry.circle_out_move(yx, direction) + position_i = self.get_position_index(yx) + cur_shrunk = work_tile(position_i) + if cur_shrunk and yx in targets: + targets.remove(yx) + shrunk = shrunk or cur_shrunk + distance += 1 # print('DEBUG Dijkstra') # line_to_print = [] # x = 0 # 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 +324,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,14 +377,15 @@ 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 if unmerged: self.shadow_cones += [cone] - step_size = (CIRCLE / len(self.circle_out_directions)) / distance_to_center + step_size = (CIRCLE / len(self.geometry.circle_out_directions))\ + / distance_to_center number_steps = dir_i * distance_to_center + dir_progress left_arm = correct_arm(step_size / 2 + step_size * number_steps) right_arm = correct_arm(left_arm + step_size) @@ -349,13 +398,8 @@ class FovMap(SourcedMap): else: eval_cone([left_arm, right_arm]) - def basic_circle_out_move(self, pos, direction): - mover = getattr(self.geometry, 'move__' + direction) - 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 @@ -363,30 +407,10 @@ class FovMap(SourcedMap): distance = 1 yx = YX(yx.y, yx.x) while distance <= self.radius: - yx = self.basic_circle_out_move(yx, 'RIGHT') - for dir_i in range(len(self.circle_out_directions)): + yx = self.geometry.basic_circle_out_move(yx, 'RIGHT') + for dir_i in range(len(self.geometry.circle_out_directions)): 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) + direction = self.geometry.circle_out_directions[dir_i] + yx = self.geometry.circle_out_move(yx, direction) + f(yx, distance, dir_i, dir_progress) distance += 1 - - - -class FovMapHex(FovMap): - circle_out_directions = ('DOWNLEFT', 'LEFT', 'UPLEFT', - 'UPRIGHT', 'RIGHT', 'DOWNRIGHT') - - def circle_out_move(self, yx, direction): - return self.basic_circle_out_move(yx, direction) - - - -class FovMapSquare(FovMap): - circle_out_directions = (('DOWN', 'LEFT'), ('LEFT', 'UP'), - ('UP', 'RIGHT'), ('RIGHT', 'DOWN')) - - def circle_out_move(self, yx, direction): - yx = self.basic_circle_out_move(yx, direction[0]) - return self.basic_circle_out_move(yx, direction[1])