X-Git-Url: https://plomlompom.com/repos/%7B%7Bdb.prefix%7D%7D/calendar?a=blobdiff_plain;f=plomrogue%2Fmapping.py;h=9fecffb6bcb06a1740dc950138018c6fe0dfb85a;hb=3795deac19be4816d54829ed2e728e78f57f86de;hp=e0a59d8e225f56af79b0b516bb7f6e366de164a4;hpb=540aec0e9bf55d0452cffda4b34e1995d3724abf;p=plomrogue2 diff --git a/plomrogue/mapping.py b/plomrogue/mapping.py index e0a59d8..9fecffb 100644 --- a/plomrogue/mapping.py +++ b/plomrogue/mapping.py @@ -20,6 +20,7 @@ class MapGeometry(): def __init__(self, size): self.size = size + self.neighbors_i = {} def get_directions(self): directions = [] @@ -34,6 +35,21 @@ class MapGeometry(): neighbors[direction] = self.move(pos, direction) return neighbors + def get_neighbors_i(self, i): + if i in self.neighbors_i: + return self.neighbors_i[i] + pos = YX(i // self.size.x, i % self.size.x) + neighbors_pos = self.get_neighbors(pos) + neighbors_i = {} + for direction in neighbors_pos: + pos = neighbors_pos[direction] + if pos is None: + neighbors_i[direction] = None + else: + neighbors_i[direction] = pos.y * self.size.x + pos.x + self.neighbors_i[i] = neighbors_i + return self.neighbors_i[i] + def move(self, start_pos, direction): mover = getattr(self, 'move_' + direction) target = mover(start_pos) @@ -56,6 +72,10 @@ class MapGeometryWithLeftRightMoves(MapGeometry): class MapGeometrySquare(MapGeometryWithLeftRightMoves): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.fov_map_class = FovMapSquare + def move_UP(self, start_pos): return YX(start_pos.y - 1, start_pos.x) @@ -63,9 +83,12 @@ class MapGeometrySquare(MapGeometryWithLeftRightMoves): return YX(start_pos.y + 1, start_pos.x) - class MapGeometryHex(MapGeometryWithLeftRightMoves): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.fov_map_class = FovMapHex + def move_UPLEFT(self, start_pos): start_indented = start_pos.y % 2 if start_indented: @@ -112,6 +135,18 @@ class Map(): else: self.terrain[pos_i] = c + def __iter__(self): + """Iterate over YX position coordinates.""" + for y in range(self.size.y): + for x in range(self.size.x): + yield YX(y, x) + + # TODO: use this for more refactoring + def inside(self, yx): + if yx.y < 0 or yx.x < 0 or yx.y >= self.size.y or yx.x >= self.size.x: + return False + return True + @property def size_i(self): return self.size.y * self.size.x @@ -134,3 +169,150 @@ class Map(): width = self.size.x for y in range(self.size.y): yield (y, self.terrain[y * width:(y + 1) * width]) + + + +class FovMap(Map): + # TODO: player visibility asymmetrical (A can see B when B can't see A): + # does this make sense, or not? + + def __init__(self, source_map, source_center): + self.source_map = source_map + self.fov_radius = 12 + self.set_size_offset_center(source_center) + self.terrain = '?' * self.size.y * self.size.x + self[self.center] = '.' + self.geometry = self.geometry_class(self.size) + self[self.center] = '.' + self.shadow_cones = [] + self.circle_out(self.center, self.shadow_process) + + def throws_shadow(self, source_yx): + return self.source_map[source_yx] == 'X' + + def source_yx(self, yx): + source_yx = yx + self.offset + if not self.source_map.inside(source_yx): + return False + return source_yx + + def shadow_process(self, yx, source_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. + + def correct_arm(arm): + if arm > CIRCLE: + arm -= CIRCLE + return arm + + def in_shadow_cone(new_cone): + for old_cone in self.shadow_cones: + if old_cone[0] <= new_cone[0] and \ + new_cone[1] <= old_cone[1]: + return True + # We might want to also shade tiles whose middle arm is inside a + # shadow cone for a darker FOV. Note that we then could not for + # optimization purposes rely anymore on the assumption that a + # shaded tile cannot add growth to existing shadow cones. + return False + + def merge_cone(new_cone): + import math + for old_cone in self.shadow_cones: + if new_cone[0] < old_cone[0] and \ + (new_cone[1] > old_cone[0] or + math.isclose(new_cone[1], old_cone[0])): + old_cone[0] = new_cone[0] + return True + if new_cone[1] > old_cone[1] and \ + (new_cone[0] < old_cone[1] or + math.isclose(new_cone[0], old_cone[1])): + old_cone[1] = new_cone[1] + return True + return False + + def eval_cone(cone): + if in_shadow_cone(cone): + return + self[yx] = '.' + if self.throws_shadow(source_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 + 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) + + # Optimization potential: left cone could be derived from previous + # right cone. Better even: Precalculate all cones. + if right_arm < left_arm: + eval_cone([left_arm, CIRCLE]) + eval_cone([0, right_arm]) + else: + eval_cone([left_arm, right_arm]) + + def basic_circle_out_move(self, pos, direction): + #"""Move position pos into direction. Return whether still in map.""" + 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 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 + # would lose shade growth through tiles at shade borders.) + circle_in_map = True + distance = 1 + yx = YX(yx.y, yx.x) + while distance <= self.fov_radius: + yx = self.basic_circle_out_move(yx, 'RIGHT') + for dir_i in range(len(self.circle_out_directions)): + for dir_progress in range(distance): + direction = self.circle_out_directions[dir_i] + yx = self.circle_out_move(yx, direction) + source_yx = self.source_yx(yx) + if source_yx: + f(yx, source_yx, distance, dir_i, dir_progress) + distance += 1 + + + +class FovMapHex(FovMap): + circle_out_directions = ('DOWNLEFT', 'LEFT', 'UPLEFT', + 'UPRIGHT', 'RIGHT', 'DOWNRIGHT') + geometry_class = MapGeometryHex + + def set_size_offset_center(self, source_center): + indent = 1 if (source_center.y % 2) else 0 + self.size = YX(2 * self.fov_radius + 1 + indent, + 2 * self.fov_radius + 1) + self.offset = YX(source_center.y - self.fov_radius - indent, + source_center.x - self.fov_radius) + self.center = YX(self.fov_radius + indent, self.fov_radius) + + 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')) + geometry_class = MapGeometrySquare + + def set_size_offset_center(self, source_center): + self.size = YX(2 * self.fov_radius + 1, 2 * self.fov_radius + 1) + self.offset = YX(source_center.y - self.fov_radius, + source_center.x - self.fov_radius) + self.center = YX(self.fov_radius, self.fov_radius) + + 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])