def __init__(self, size):
self.size = size
self.neighbors_i = {}
+ self.directions = self.get_directions()
def get_directions(self):
directions = []
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
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):
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)
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)
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)]
if width_line != width_map:
raise ArgError('map line width %s unequal map width %s' % (width_line, width_map))
self.terrain = self.terrain[:y * width_map] + line +\
- self.terrain[(y + 1) * width_map:]
+ self.terrain[(y + 1) * width_map:]
def get_position_index(self, yx):
return yx.y * self.geometry.size.x + yx.x
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))
+ 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
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
- #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:
- # x = 0
- # print(' '.join(line_to_print))
- # line_to_print = []
+ 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.geometry.size.x:
+ # x = 0
+ # print(' '.join(line_to_print))
+ # line_to_print = []
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
- self.terrain = '?' * self.size_i #self.size.y * self.size.x
+ 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.
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]:
+ 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
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)
+ 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
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
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])