def __init__(self, line: LineToMiddle, robot: Robot,
shared_grid_access: SharedGridAccess,
goal_building: GoalBuilding):
super().__init__(robot, shared_grid_access, goal_building)
self.shared_actions_executor = RobotSharedActionsExecutor(
robot=robot,
shared_grid_access=shared_grid_access,
private_grid=self.private_grid,
robot_coordinates=self.robot_coordinates)
self.line = line.copy()
self.line_scanner = LineScannerExecutor(self.shared_actions_executor)
def _split_goal(self):
if self.is_splitted:
return
width = self.goal_building.width
height = self.goal_building.height
# first add elements that are not on diagonals
# test_array = np.zeros((width, height), dtype=int)
edge_block_counts = np.zeros(
4, dtype=int) # how many blocks each edge have assigned
raising_diag_grid = np.zeros((width, height),
dtype=bool) # True if diag on field
decreasing_diag_grid = np.zeros((width, height), dtype=bool)
if width == 1 or height == 1:
raise ValueError("goal_building should be at least 3x3")
if (width % 2 == 1) and (height % 2 == 1):
mid_block_x = width // 2
mid_block_y = height // 2
mid_block_pos = (mid_block_x, mid_block_y)
decreasing_diag_grid[mid_block_pos] = True
raising_diag_grid[mid_block_pos] = True
# D 0 R
# 0 RD 0
# R 0 D
decreasing_diag_left_pos = Coordinates(mid_block_x - 1,
mid_block_y + 1)
decreasing_diag_grid[
decreasing_diag_left_pos.get_array_index()] = True
decreasing_diag_right_pos = Coordinates(mid_block_x + 1,
mid_block_y - 1)
decreasing_diag_grid[
decreasing_diag_right_pos.get_array_index()] = True
raising_diag_left_pos = Coordinates(mid_block_x - 1,
mid_block_y - 1)
raising_diag_grid[raising_diag_left_pos.get_array_index()] = True
raising_diag_right_pos = Coordinates(mid_block_x + 1,
mid_block_y + 1)
raising_diag_grid[raising_diag_right_pos.get_array_index()] = True
else:
# D R
# R D
left_x = width // 2 - 1
if height % 2 == 0:
down_y = height // 2 - 1
else:
down_y = height // 2
decreasing_diag_left_pos = Coordinates(left_x, down_y + 1)
decreasing_diag_grid[
decreasing_diag_left_pos.get_array_index()] = True
decreasing_diag_right_pos = Coordinates(left_x + 1, down_y)
decreasing_diag_grid[
decreasing_diag_right_pos.get_array_index()] = True
raising_diag_left_pos = Coordinates(left_x, down_y)
raising_diag_grid[raising_diag_left_pos.get_array_index()] = True
raising_diag_right_pos = Coordinates(left_x + 1, down_y + 1)
raising_diag_grid[raising_diag_right_pos.get_array_index()] = True
top_right_corner_walker = ToCornerWalker(raising_diag_grid,
x_direction=Direction.RIGHT,
y_direction=Direction.UP,
pos=raising_diag_right_pos,
width=width,
height=height)
top_right_corner_walker.update_diag_to_corner()
down_right_corner_walker = ToCornerWalker(
decreasing_diag_grid,
x_direction=Direction.RIGHT,
y_direction=Direction.DOWN,
pos=decreasing_diag_right_pos,
width=width,
height=height)
down_right_corner_walker.update_diag_to_corner()
down_left_corner_walker = ToCornerWalker(raising_diag_grid,
x_direction=Direction.LEFT,
y_direction=Direction.DOWN,
pos=raising_diag_left_pos,
width=width,
height=height)
down_left_corner_walker.update_diag_to_corner()
top_left_corner_walker = ToCornerWalker(decreasing_diag_grid,
x_direction=Direction.LEFT,
y_direction=Direction.UP,
pos=decreasing_diag_left_pos,
width=width,
height=height)
top_left_corner_walker.update_diag_to_corner()
both_diags = (raising_diag_grid + 2 * decreasing_diag_grid)
# now we want to create lines for each edge:
edge_builds: List[EdgeBuild] = list()
edge_num = -1
for direction in self.spin.get_directions():
edge_num += 1
edge_build = EdgeBuild(width, height, direction.get_opposite())
edge_builds.append(edge_build)
if direction.is_x_axis():
# for x axis we have y axis length amount of lines
edge_len = height
opposite_len = width
else:
edge_len = width
opposite_len = height
# for each line
for i in range(edge_len):
# if direction = UP
# we would have something like this:
# if rising then last index
if direction == Direction.LEFT:
line_scan_coordinate = Coordinates(0, i)
elif direction == Direction.UP:
line_scan_coordinate = Coordinates(i, opposite_len - 1)
elif direction == Direction.RIGHT:
line_scan_coordinate = Coordinates(opposite_len - 1, i)
else: # DOWN
line_scan_coordinate = Coordinates(i, 0)
edge_builds[edge_num].add_line_start(line_scan_coordinate)
for j in range(opposite_len):
diag_tile = both_diags[
line_scan_coordinate.get_array_index()]
if diag_tile:
if diag_tile != 10 and self.goal_building.grid[
line_scan_coordinate.get_array_index()]:
both_diags[
line_scan_coordinate.get_array_index()] = 10
# TODO: decide where this tile goes
# decide_later.append(block_line, coordinate, edge_set) something like this
# for now lets just add to first that got this
edge_builds[edge_num].block_lines[(i, j)] = True
edge_block_counts[edge_num] += 1
break
if self.goal_building.grid[
line_scan_coordinate.get_array_index()]:
edge_builds[edge_num].block_lines[(i, j)] = True
edge_block_counts[edge_num] += 1
line_scan_coordinate = line_scan_coordinate.create_neighbour_coordinate(
direction.get_opposite())
diags = (raising_diag_grid + 2 * decreasing_diag_grid)
edge_num = -1
self.edges: List[GridEdge] = list()
for direction in self.spin.get_directions():
edge_num += 1
edge_build = edge_builds[edge_num]
lines: List[LineToMiddle] = list()
for i in range(edge_build.length):
line = LineToMiddle(edge_build.line_starts[i],
direction.get_opposite(),
edge_build.block_lines[i])
lines.append(line)
line_copy = line.copy()
while not line_copy.is_finished():
pos = line_copy.get_next_block_position()
line_copy.place_block()
if direction == Direction.LEFT:
diags[pos.get_array_index()] += 10
elif direction == Direction.RIGHT:
diags[pos.get_array_index()] += 20
elif direction == Direction.DOWN:
diags[pos.get_array_index()] += 40
else:
diags[pos.get_array_index()] += 80
edge = GridEdge(self.spun_source_positions, lines, direction,
self.spin)
self.edges.append(edge)
# # TODO: delete later this is just for debug:
diags = diags.T
# diags = np.flip(diags, 1)
diags = np.flip(diags, 0)
print(diags, "a")
def __init__(self, line: LineToMiddle, robot: Robot,
shared_grid_access: SharedGridAccess,
goal_building: GoalBuilding):
super().__init__(robot, shared_grid_access, goal_building, 0.0001)
self.line = line.copy()
self.line_scanner = LineScannerExecutor(self.shared_actions_executor)