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 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 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 calc_path_astar(self, ordered):
"""
Calculate the walking path using the A* algorithm
:param ordered: ordered set of coordinates.
:return: path, distance
"""
distance = 0
full_path = []
# make sure all destination points are walkable
for o in ordered:
x, y = o
self.slayout.walkable[x, y] = 1
# calculate path
for i in range(len(ordered)-1):
# define the grid and the solver
grid = Grid(matrix=self.slayout.walkable)
finder = AStarFinder(diagonal_movement=DiagonalMovement.always)
start = ordered[i]
start_node = grid.node(start[1], start[0])
end = ordered[i+1]
end_node = grid.node(end[1], end[0])
path, runs = finder.find_path(start_node, end_node, grid)
distance += len(path)
full_path.extend(path)
return full_path, distance
def index():
matrix = request.json['matrix']
start_pos = request.json['start']
end_pos = request.json['end']
finder_name = request.json['finder']
is_diagonal = request.json['isDiagonal']
grid = Grid(matrix=matrix)
start = grid.node(start_pos[0], start_pos[1])
end = grid.node(end_pos[0], end_pos[1])
diagonal_movement = DiagonalMovement.always if is_diagonal else DiagonalMovement.never
finder = None
if finder_name == 'a_star':
finder = AStarFinder(diagonal_movement=diagonal_movement)
elif finder_name == 'breadth_first':
finder = BreadthFirstFinder(diagonal_movement=diagonal_movement)
elif finder_name == 'bi_a_star':
finder = BiAStarFinder(diagonal_movement=diagonal_movement)
elif finder_name == 'best_first':
finder = BestFirst(diagonal_movement=diagonal_movement)
elif finder_name == 'dijkstra':
finder = DijkstraFinder(diagonal_movement=diagonal_movement)
elif finder_name == 'ida_star':
finder = IDAStarFinder(diagonal_movement=diagonal_movement)
path, runs = finder.find_path(start, end, grid)
return jsonify({
"path": path,
"steps": len(path),
"finder_name": finder_name
})
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 generate_hall_1(self, matrix):
doors = self.doors
if len(doors) == 2:
door1, door2 = doors
mini = np.negative(matrix.copy()).tolist()
for s, y in enumerate(mini):
for t, x in enumerate(y):
if mini[s][t] == 0 or mini[s][t] == -4:
mini[s][t] = 1
grid = Grid(matrix=mini)
finder = BestFirst(diagonal_movement=DiagonalMovement.never,
heuristic=manhatten)
start = grid.node(door1[0], door1[1])
end = grid.node(door2[0], door2[1])
pos, _ = finder.find_path(start, end, grid)
for p in pos:
if (p[1] == doors[1][1]) and (p[0] == doors[1][0]):
matrix[p[1], p[0]] = 4
elif (p[1] == doors[0][1]) and (p[0] == doors[0][0]):
matrix[p[1], p[0]] = 4
else:
matrix[p[1], p[0]] = 2
self.meta = doors + pos
return matrix
class Map:
def __init__(self):
self.map = []
self.finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
def load(self, path):
im = Image.open(path)
w, h = im.size
v = list(
map(lambda p: 1 if (p[0] + p[1] + p[2]) // 3 > 127 else 0,
im.getdata()))
self.grid = Grid(matrix=[v[i * w:(i + 1) * w] for i in range(h)])
def width(self):
return len(self.map[0])
def height(self):
return len(self.map)
def find_path(self, a, b):
start = self.grid.node(a[0], a[1])
end = self.grid.node(b[0], b[1])
path, runs = self.finder.find_path(start, end, self.grid)
self.grid.cleanup()
return path
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(self, start, end, angle=None):
print(start, end)
self.img = self.warehouse.getImage()
preproc = self.preprocess(self.img)
angle = None
if angle is not None:
preproc = self.buildPerimiter(start, angle, 35, preproc)
plt.imsave("pre.png", preproc)
self.imshow(preproc)
# 7.34 and 9.04 are actual dimension in the sim env
grid = Grid(matrix=preproc)
startGrid = grid.node(*start)
endGrid = grid.node(*end)
finder = AStarFinder(diagonal_movement=DiagonalMovement)
print("Finding")
path, _ = finder.find_path(startGrid, endGrid, grid)
if len(path) == 0:
print("exit")
return ([], [])
print(path[0])
print("found")
path = path[0::4]
self.path = [[p[0], p[1]] for p in path]
self.path = self.smooth(30, 0.6, 40)
actualPath = []
for point in path:
actualPath.append(self.warehouse.img_to_warehouse(*point))
return (self.path, actualPath)
def finder_path(field, gps_actual, gps_target, finder=AStarFinder):
"""Shortest pathfinding algorithms.
Args:
field (np.ndarray):
The current field of fake environment.
gps_actual (tulple):
The current position of RL agent.
gps_actual (tulple):
The target position.
finder (optional):
Choose different algorithms. Defaults to AStarFinder.
Returns:
Each grid position of shortest path.
"""
grid = field.copy()
grid[grid > 0] = 99
grid[grid == 0] = 1
grid[grid == 99] = 0
grid = grid.astype(int)
grid = grid.tolist()
grid = Grid(matrix=grid)
# find path
sx, sy = gps_actual
tx, ty = gps_target
start = grid.node(sy, sx)
end = grid.node(ty, tx)
finder = finder()
path, _ = finder.find_path(start, end, grid)
return path
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(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)
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 find_path(game_state, board_matrix, x, y, targetx, targety):
height = game_state["board"]["height"]
grid = Grid(width=height, height=height, matrix=board_matrix)
start = grid.node(x, y)
end = grid.node(targetx, targety)
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
if (len(path) > 0):
pathx = path[1][0]
pathy = path[1][1]
# print("Next Move Coordinates "+ str(path[1][0]) + ", " + str(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
return "up"
# go down
if ((y + 1) == pathy) and (x == pathx):
directions["down"] += 20
return "down"
# go left
if ((x - 1) == pathx) and (y == pathy):
directions["left"] += 20
return "left"
# go right
if ((x + 1) == pathx) and (y == pathy):
directions["right"] += 20
return "right"
def find_path(challenge, start, end):
# Convert paths appropriately
for y in range(len(challenge)):
for x in range(len(challenge[y])):
if challenge[y][x] == "-":
challenge[y][x] = 1
else:
challenge[y][x] = 0
# Use library to find our path
grid = Grid(matrix=challenge)
start = grid.node(start[1], start[0])
end = grid.node(end[1], end[0])
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path_nodes, _ = finder.find_path(start, end, grid)
# Convert path to wasd
previous = None
path = ""
for step in path_nodes:
if previous is not None:
if step[1] < previous[1]:
path += "w"
if step[0] < previous[0]:
path += "a"
if step[1] > previous[1]:
path += "s"
if step[0] > previous[0]:
path += "d"
previous = step
# Return path
return path
def find_path(self, a, b, grid):
path_grid = Grid(matrix=grid)
start = path_grid.node(a[0], a[1])
end = path_grid.node(b[0], b[1])
finder = BestFirst(diagonal_movement=DiagonalMovement.always)
path, _runs = finder.find_path(start, end, path_grid)
return path
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 find_path(matrix):
grid = Grid(matrix=matrix)
start = grid.node(0, 0) # Given in (x, y) or (col, row)
end = grid.node(3, 6) # TODO: must change this
finder = AStarFinder()
path, runs = finder.find_path(start, end, grid)
return path
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 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 move(self, caves, allies, enemies):
possiblesquares = []
for enemy in enemies:
if len(enemy.getadjacent(caves, allies, enemies)) > 0:
possiblesquares.append(
enemy.getadjacent(caves, allies, enemies))
if len(possiblesquares) > 0:
grid = Grid(matrix=createGrid(caves, allies, enemies))
finder = BreadthFirstFinder(
diagonal_movement=DiagonalMovement.never)
start = grid.node(self.x, self.y)
minimum = None
for i, squares in enumerate(possiblesquares):
for square in squares:
end = grid.node(square[0], square[1])
path, runs = finder.find_path(start, end, grid)
#if self.x == 3 and self.y == 1:
#print(grid.grid_str(path=path, start=start, end=end))
if len(path) == 0:
continue
if minimum == None or len(path) < minimum[0] or (
len(path) == minimum[0]
and square[2] < minimum[2]):
minimum = [
len(path), path[1], square[2], square[0], square[1]
]
grid.cleanup()
grid.cleanup()
if minimum != None:
selected = None
end = grid.node(minimum[3], minimum[4])
for mysquare in self.getadjacent(caves, allies, enemies):
start = grid.node(mysquare[0], mysquare[1])
path, runs = finder.find_path(start, end, grid)
#print(grid.grid_str(path=path, start=start, end=end))
if len(path) == 0:
continue
if selected == None or len(path) < selected[0] or (
len(path) == selected[0]
and mysquare[2] < selected[2]):
selected = [
len(path), path[0], mysquare[2], mysquare[0],
mysquare[1]
]
grid.cleanup()
self.x = selected[3]
self.y = selected[4]
if any(self.y + 1 == e.y and self.x == e.x
for e in enemies) or any(
self.y - 1 == e.y and self.x == e.x
for e in enemies) or any(
self.y == e.y and self.x + 1 == e.x
for e in enemies) or any(
self.y == e.y and self.x - 1 == e.x
for e in enemies):
enemies = self.attack(caves, allies, enemies)
return enemies
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 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 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 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 find_moves(mob, range, grid):
matrix = grid_to_matrix(grid)
results = list()
for square in range:
maze = Grid(matrix=matrix)
start = maze.node(mob[1], mob[2])
end = maze.node(square[0], square[1])
path, runs = finder.find_path(start, end, maze)
if len(path) > 0:
results.append([square[0], square[1], len(path) - 1, path[1]])
return (results)
def findPath(sx, sy, ex, ey, pathOrlength):
grid = Grid(matrix=layout) # to reset the grid and remove old marks
start = grid.node(sx, sy)
end = grid.node(ex, ey)
finder = BreadthFirstFinder() #finder = BreadthFirstFinder(diagonal_movement=DiagonalMovement.never)
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))
# print(path)
if pathOrlength: return len(path)
else: 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 test_path_diagonal():
# test diagonal movement
for scenario in data:
for find in finders:
grid = Grid(matrix=scenario['matrix'])
start = grid.node(scenario['startX'], scenario['startY'])
end = grid.node(scenario['endX'], scenario['endY'])
finder = find(diagonal_movement=DiagonalMovement.always)
path, runs = finder.find_path(start, end, grid)
print(find.__name__, runs, len(path))
print(grid.grid_str(path=path, start=start, end=end))
