-class MapFovHex(MapHex):
-
- def __init__(self, source_map, yx):
- self.source_map = source_map
- self.size = self.source_map.size
- self.terrain = '?' * self.size_i
- self[yx] = '.'
- self.shadow_cones = []
- self.circle_out(yx, self.shadow_process_hex)
-
- def shadow_process_hex(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.
-
- def correct_arm(arm):
- if arm < 0:
- 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]:
- #print('DEBUG shadowed by:', old_cone)
- return True
- # We might want to also shade hexes 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 hex cannot add growth to existing shadow cones.
- return False
-
- def merge_cone(new_cone):
- 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])):
- #print('DEBUG merging to', old_cone)
- old_cone[0] = new_cone[0]
- #print('DEBUG merged cone:', old_cone)
- 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])):
- #print('DEBUG merging to', old_cone)
- old_cone[1] = new_cone[1]
- #print('DEBUG merged cone:', old_cone)
- return True
- return False
-
- def eval_cone(cone):
- #print('DEBUG CONE', cone, '(', step_size, distance_to_center, number_steps, ')')
- if in_shadow_cone(cone):
- return
- self[yx] = '.'
- if self.source_map[yx] != '.':
- #print('DEBUG throws shadow', cone)
- unmerged = True
- while merge_cone(cone):
- unmerged = False
- if unmerged:
- self.shadow_cones += [cone]
-
- #print('DEBUG', yx)
- step_size = (CIRCLE/6) / 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, 0])
- eval_cone([CIRCLE, right_arm])
- else:
- eval_cone([left_arm, right_arm])
-
- def circle_out(self, yx, f):
- # Optimization potential: Precalculate movement positions. (How to check
- # circle_in_map then?)
- # Optimization potential: Precalculate what hexes are shaded by what hex
- # and skip evaluation of already shaded hexes. (This only works if hex
- # shading implies they completely lie in existing shades; otherwise we
- # would lose shade growth through hexes at shade borders.)
-
- def move(pos, direction):
- """Move position pos into direction. Return whether still in map."""
- mover = getattr(self, 'move_' + direction)
- pos[:] = mover(pos)
- if pos[0] < 0 or pos[1] < 0 or \
- pos[0] >= self.size[0] or pos[1] >= self.size[1]:
- return False
- return True
-
- # TODO: Start circling only in earliest obstacle distance.
- directions = ('DOWNLEFT', 'LEFT', 'UPLEFT', 'UPRIGHT', 'RIGHT', 'DOWNRIGHT')
- circle_in_map = True
- distance = 1
- yx = yx[:]
- #print('DEBUG CIRCLE_OUT', yx)
- while circle_in_map:
- circle_in_map = False
- move(yx, 'RIGHT')
- for dir_i in range(len(directions)):
- for dir_progress in range(distance):
- direction = directions[dir_i]
- if move(yx, direction):
- f(yx, distance, dir_i, dir_progress)
- circle_in_map = True
- distance += 1
-
-