def is_playable(start_end: List, room_matrix: List[List[int]], print_path: bool=False) -> bool:
if len(start_end) < 2:
playable = True
return playable
grid = Grid(matrix=room_matrix)
comb = list(combinations(start_end, 2))
playable = True
# random.shuffle(comb)
for _start, _end in comb:
# print(_start, _end)
abs_dis = abs(_start[0] - _end[0]) + abs(_start[1] - _end[1])
if abs_dis < 2:
continue
start = grid.node(_start[1], _start[0])
end = grid.node(_end[1], _end[0])
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
if print_path:
print('operations:', runs, 'path length:', len(path))
print(grid.grid_str(path=path, start=start, end=end))
grid.cleanup()
if len(path) == 0:
playable = False
break
return playable
def find_path_to_snack(Snake_bodies,Start_pos,Snack_pos):
Clear_Grid=[]
Grid_factor=4
Grid_size=[int(16*Grid_factor),int(9*Grid_factor)]
for loop in range(Grid_size[1]):
Clear_Grid.append([ 1 ]*Grid_size[0])
for position in Snake_bodies:
#print(position)
#print(Clear_Grid[position[1]])
# if position[0]==Grid_size[0] and position[1]<Grid_size[1]:
# position=(63,position[1])
try:
Clear_Grid[position[1]][position[0]]=0
except:
print('Error snake off grid')
pass
grid = Grid(matrix=Clear_Grid)
start = grid.node(Start_pos[0], Start_pos[1])
end = grid.node(Snack_pos[0], Snack_pos[1])
finder = AStarFinder()
path, runs = finder.find_path(start, end, grid)
#print(path)
#print(grid.grid_str(path=path, start=start, end=end))
#print('found path')
return path
#print(find_path_to_snack(Clear_Grid,[(25,22),(12,20)],(2,0),(10,30)))
#find_path_to_snack(
#print(find_path_to_snack([(25, 2), (2, 33), (1, 33), (0, 33), (63, 33)], (3, 33) ,(60, 7)))
def generate_move(self, agent):
matrix = list(
map(map_list_bool_to_int,
np.array(agent._game.state) != 1))
grid = Grid(matrix=matrix)
agent_location = agent._current_location
pacman_location = agent._game.pacman._current_location
dist = math.sqrt(
pow(agent_location[0] - pacman_location[0], 2) +
pow(agent_location[1] - pacman_location[1], 2))
if dist > 6:
return ValidRandom().generate_move(agent)
start = grid.node(agent_location[0], agent_location[1])
end = grid.node(pacman_location[0], pacman_location[1])
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
target_next = path[1]
if agent_location[0] < target_next[0]:
return 'R'
elif agent_location[0] > target_next[0]:
return 'L'
if agent_location[1] < target_next[1]:
return 'D'
elif agent_location[1] > target_next[1]:
return 'U'
def findDistToGoal(mapList, pos, goal):
#invert map for A* purposes. In this library, 0 is obstacle 1 is free. so invert
mapMatrix = np.ones((len(mapList), len(mapList[0])))
for i in range(0, len(mapList)):
for j in range(0, len(mapList[0])):
if (mapList[i][j] == 0):
mapMatrix[i][j] = 1
else:
mapMatrix[i][j] = 0
grid = Grid(matrix=mapMatrix)
start = grid.node(pos[0], pos[1])
end = grid.node(goal[0], goal[1])
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
print(grid.grid_str(path=path, start=start, end=end))
print(path)
dist = 0
if (len(path) > 2):
dist = len(path) - 1
elif (len(path) == 2):
dist = 1
elif (len(path) == 1):
dist = 0
else:
dist = -1
return dist
def find_path(location_dict, start_point, end_point, grid):
start = grid.node(location_dict[start_point][0],
location_dict[start_point][1])
end = grid.node(location_dict[end_point][0], location_dict[end_point][1])
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
return path
def optimal_action(self, state=None):
if state is None:
state = self.state
# TODO: Save actions
grid = Grid(matrix=(1 - self.grid))
start = grid.node(state.agent_pos[1], state.agent_pos[0])
end = grid.node(state.goal_pos[1], state.goal_pos[0])
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
dif_h = path[1][1] - path[0][1]
dif_w = path[1][0] - path[0][0]
# Down, Up, Right, Left
if dif_w != 0:
if dif_w > 0:
return 2
elif dif_w < 0:
return 3
elif dif_h != 0:
if dif_h > 0:
return 0
elif dif_h < 0:
return 1
def find_path(state, board_matrix, foodx, foody):
height = state["board"]["height"]
y = state['you']["body"][0]["y"]
x = state['you']["body"][0]["x"]
grid = Grid(width=height, height=height, matrix=board_matrix)
start = grid.node(x, y)
end = grid.node(foodx, foody)
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
if len(path) > 1:
pathx = path[1][0]
pathy = path[1][1]
# go up
if ((y - 1) == pathy) and (x == pathx):
return 'up'
# go down
if ((y + 1) == pathy) and (x == pathx):
return 'down'
# go left
if ((x - 1) == pathx) and (y == pathy):
return 'left'
# go right
if ((x + 1) == pathx) and (y == pathy):
return 'right'
else:
# If there are no valid moves to food pick a random move
return random_move()
def get_lowest_risk_path(map):
grid = Grid(matrix=map)
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
start = grid.node(0, 0)
end = grid.node(len(map[0]) - 1, len(map) - 1)
path, runs = finder.find_path(start, end, grid)
return sum([map[node[1]][node[0]] for node in path[1:]])
def move(self):
"""
Metoda poruszająca agenta
Kiedy nikogo nie widzi porusza się losowo
Jak widzi to idzie w jego stronę najszybszą ścieżką
:return:
"""
others = self.scout(18)
if len(others) < 1:
self.model.grid.move_agent(
self, self.random.choice(self.nearest_fields(1)))
else:
nemesis = self.random.choice(others)
self.update_path(nemesis)
start = self.Grid.node(self.pos[0], self.pos[1])
end = self.Grid.node(nemesis.pos[0], nemesis.pos[1])
finder = AStarFinder(diagonal_movement=DiagonalMovement.always)
path, runs = finder.find_path(start, end, self.Grid)
if len(path) > 0:
if self.model.grid.is_cell_empty((path[1][0], path[1][1])):
self.model.grid.move_agent(self, (path[1][0], path[1][1]))
else:
print("im stuck")
self.Grid.cleanup()
def find_path(game_state, board_matrix, x, y, foodx, foody):
height = game_state["board"]["height"]
grid = Grid(width=height, height=height, matrix=board_matrix)
start = grid.node(x, y)
end = grid.node(foodx, foody)
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
print(path)
if (len(path) > 0):
pathx = path[1][0]
pathy = path[1][1]
y = game_state['you']["body"][0]["y"]
x = game_state['you']["body"][0]["x"]
# go up
if ((y - 1) == pathy) and (x == pathx):
directions["up"] += 20
print("Pick: UP")
# go down
if ((y + 1) == pathy) and (x == pathx):
directions["down"] += 20
print("Pick: down")
# go left
if ((x - 1) == pathx) and (y == pathy):
directions["left"] += 20
print("Pick: left")
# go right
if ((x + 1) == pathx) and (y == pathy):
directions["right"] += 20
print("Pick: right")
def solve_maze(maze):
level = []
for row in maze:
newrow = []
for element in row:
if (element == '#'):
newrow.append(0)
elif (element == ' '):
newrow.append(1)
elif (element == 'P'):
newrow.append(2)
elif (element == 'G'):
newrow.append(3)
level.append(newrow)
grid = Grid(matrix=level)
start_y, start_x = index_2d(level, 2)
end_y, end_x = index_2d(level, 3)
start_node = grid.node(start_x, start_y)
end_node = grid.node(end_x, end_y)
finder = AStarFinder()
path, runs = finder.find_path(start_node, end_node, grid)
output = parse_list_to_op_string(path)
return output
def find_path(self, grid, final):
x = self.location[0]
y = self.location[1]
start = grid.node(x, y)
end = grid.node(final[0], final[1])
finder = AStarFinder()
self.path, runs = finder.find_path(start, end, grid)
Grid.cleanup(grid)
def path_finder(player, opponent, object_tiles, new_pos):
matrix = create_matrix(player, opponent, object_tiles)
grid = Grid(matrix=matrix)
start = grid.node(player.moved_hero.pos[0], player.moved_hero.pos[1])
end = grid.node(*new_pos)
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
return add_side(path)
def findPath(map, startx, starty, endx, endy): grid = Grid(matrix=map) # (x, y) = (col, row) start = grid.node(startx, starty) end = grid.node(endx, endy) finder = AStarFinder(diagonal_movement=DiagonalMovement.never) path, runs = finder.find_path(start, end, grid) return path
def find_path(location_dict, start_point, end_point, grid):
start = grid.node(location_dict[start_point][0],
location_dict[start_point][1])
end = grid.node(location_dict[end_point][0], location_dict[end_point][1])
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
print("operations:", runs, "path length:", len(path))
return path
def __init__(self, agent):
self.agent = agent
self.newest_target_idx = None # the most recent position of the target
self.newest_target_size = None # the most recent size of the target
self.newest_path = None # the most recent path to the target
self.newest_end = None # the most recent position on the path that can be reached by moving straight (not blocked by obstacles and death zones)
self.finder = AStarFinder(
diagonal_movement=DiagonalMovement.only_when_no_obstacle
) # using A-star to find the path
def path_find(self, start, end):
grid = Grid(matrix=self.mapn)
start_node = grid.node(start[0], start[1])
end_node = grid.node(end[0], end[1])
path, runs = AStarFinder(
diagonal_movement=DiagonalMovement.never).find_path(
start_node, end_node, grid)
return path
def astar(array, start, goal):
start = list(start)
goal = list(goal)
grid = Grid(matrix=array)
finder = AStarFinder(diagonal_movement=DiagonalMovement.always)
path, runs = finder.find_path(grid.node(start[1], start[0]), grid.node(goal[1], goal[0]), grid)
return path
def get_distance_path(field, start, end):
field = np.where(field != 0, -1, 1).T
grid = Grid(matrix=field)
start = grid.node(start[0], start[1])
end = grid.node(end[0], end[1])
finder = AStarFinder()
path, runs = finder.find_path(start, end, grid)
#print(grid.grid_str(path=path, start=start, end=end))
#print(len(path))
return path
def get_path(self, to_pnt: Point, grid=None):
if not grid:
grid = self._make_grid()
pnt = grid.node(self._me.get_x(), self._me.get_y())
pnt.walkable = True
target_node = grid.node(to_pnt.get_x(), to_pnt.get_y())
target_node.walkable = True
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(pnt, target_node, grid)
self._grid = grid
return path
def find_path(self, dest, matrix=None):
if matrix is None:
matrix = self.grid.to_one_and_zeros_t()
# Finding best path with A* if possible
path_grid = PathGrid(matrix=matrix)
start = path_grid.node(*self.pos)
end = path_grid.node(*dest)
finder = AStarFinder()
path, _ = finder.find_path(start, end, path_grid)
return path
def FindPath(self, destination):
grid = Grid(matrix=self.knownMap)
start = grid.node(self.position[1], self.position[0])
end = grid.node(destination[0], destination[1])
finder = AStarFinder(diagonal_movement=DiagonalMovement.always)
self.path, runs = finder.find_path(start, end, grid)
if self.path != []:
self.whereInPath = 0
self.mode = "FOLLOW"
def pathfind(blocks, less=False):
matrix = np.ones((SIZE_X, SIZE_Y))
for i in blocks:
matrix[i[0]][i[1]] = 0
matrix[0][10] = 1
matrix[0][9] = 1
matrix[19][10] = 1
matrix[19][9] = 1
grid = Grid(matrix=matrix)
start = grid.node(10, 0)
end = grid.node(10, 19)
if less:
finder = AStarFinder(diagonal_movement=1)
else:
finder = AStarFinder(diagonal_movement=2)
(path, runs) = finder.find_path(start, end, grid)
return path
def findpath(s, e):
x1 = s[0]
y1 = s[1]
x2 = e[0]
y2 = e[1]
start = grid.node(x1, y1)
end = grid.node(x2, y2)
finder = AStarFinder()
path, runs = finder.find_path(start, end, grid)
print(path)
return path
def pathfind(self):
grid = Grid(matrix=self.pathMap.grid)
start = grid.node(self.loc[0], self.loc[1])
end = grid.node(math.floor(self.target[0]), math.floor(self.target[1]))
finder = AStarFinder()
path, runs = finder.find_path(start, end, grid)
self.path = path
if len(self.path) > 1:
self.destination = self.path[1]
elif len(self.path) != 0:
self.destination = path[0]
def getPath(self, matrix, start, end):
grid = Grid(matrix=matrix)
start = grid.node(start[0], start[1])
end = grid.node(end[0], end[1])
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
if len(path) >= 1:
print(grid.grid_str(path=path, start=start, end=end))
return path
def find_path(orig_grid, start, end, time_limit, wrap=False):
# grid = Grid(matrix=matrix, wrap = wrap)
grid = copy.deepcopy(orig_grid)
start = grid.node(start.y, start.x)
end = grid.node(end.y, end.x)
finder = AStarFinder(diagonal_movement=DiagonalMovement.never,
time_limit=time_limit)
path, runs = finder.find_path(start, end, grid)
return path
def path_find(actor, target):
level = actor.level
if not level:
return None, 0
grid = Grid(matrix=level.path_grid)
start = grid.node(actor.x, actor.y)
end = grid.node(target.x, target.y)
finder = AStarFinder(diagonal_movement=DiagonalMovement.always)
path, runs = finder.find_path(start, end, grid)
return path[1::], runs
def calc_path(m, start, goal):
m[start[1]][start[0]] = 1
m[goal[1]][goal[0]] = 1
grid = Grid(matrix=m)
print(start, goal)
start = grid.node(start[0], start[1])
end = grid.node(goal[0], goal[1])
finder = AStarFinder(diagonal_movement=DiagonalMovement.always)
path, runs = finder.find_path(start, end, grid)
print('operations:', runs, 'path length:', len(path))
print(grid.grid_str(path=path, start=start, end=end))
return path
def hunt_food(self, board, food, head):
grid = self.generate_grid(board)
start = grid.node(head["x"], head["y"])
closest_food = food[0]
end = grid.node(closest_food["x"], closest_food["y"])
finder = AStarFinder()
path = finder.find_path(start, end, grid)
move = self.get_next_move_from_path(path)
print(f"Start: {head['x']}, {head['y']}; "
f"End: {closest_food['x']}, {closest_food['y']}")
print(f"Path: {path}")
return move