def test_empty():
"""
special test for empty values
"""
matrix = ()
grid = Grid(matrix=matrix)
assert grid.grid_str() == '++\n||\n++'
matrix = np.array(matrix)
grid = Grid(matrix=matrix)
assert grid.grid_str() == '++\n||\n++'
def find_path(self, player, show=False):
"""Return True if the player can finish"""
x, y = self.pos_player_in_grid(player)
grid = Grid(matrix=self.matrix)
if player.orient == "north":
x_end = self.side - 1
for y_end in range(0, self.side, 2):
start = grid.node(y, x)
end = grid.node(y_end, x_end)
path, runs = self.finder.find_path(start, end, grid)
if path != []:
if show:
print(grid.grid_str(path=path, start=start, end=end))
return True
grid.cleanup()
elif player.orient == "east":
y_end = 0
for x_end in range(0, self.side, 2):
start = grid.node(y, x)
end = grid.node(y_end, x_end)
path, runs = self.finder.find_path(start, end, grid)
if path != []:
if show:
print(grid.grid_str(path=path, start=start, end=end))
return True
grid.cleanup()
elif player.orient == "south":
x_end = 0
for y_end in range(0, self.side, 2):
start = grid.node(y, x)
end = grid.node(y_end, x_end)
path, runs = self.finder.find_path(start, end, grid)
if path != []:
if show:
print(grid.grid_str(path=path, start=start, end=end))
return True
grid.cleanup()
elif player.orient == "west":
y_end = self.side - 1
for x_end in range(0, self.side, 2):
start = grid.node(y, x)
end = grid.node(y_end, x_end)
path, runs = self.finder.find_path(start, end, grid)
if path != []:
if show:
print(grid.grid_str(path=path, start=start, end=end))
return True
grid.cleanup()
return False
def test_str():
"""
test printing the grid
"""
grid = Grid(height=2, width=3)
assert grid.grid_str(border=False, empty_chr='x') == BORDERLESS_GRID[1:-1]
assert grid.grid_str(border=True) == BORDER_GRID[1:-1]
grid.nodes[0][1].walkable = False
start = grid.nodes[0][0]
end = grid.nodes[1][1]
path = [(0, 1)]
assert grid.grid_str(path, start, end) == WALKED_GRID[1:-1]
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 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 print_grid(self, grid=True, players=None):
"""Print the grid"""
matrix = self.matrix.copy()
if players is not None:
for p in players.players:
i, j = self.pos_player_in_grid(p)
matrix[i][j] = -1
grid = Grid(matrix=matrix)
print(grid.grid_str())
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))
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 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 path_finder(map, xs, ys, xe, ye):
grid = Grid(matrix=map)
start = grid.node(xs, ys)
end = grid.node(xe, ye)
finder = AStarFinder(diagonal_movement=DiagonalMovement.never) #always
path, runs = finder.find_path(start, end, grid)
print(f'operations: {runs} with final path length: {len(path)}')
print(grid.grid_str(path=path, start=start, end=end))
return path
def test_path():
"""
test scenarios defined in json file
"""
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()
path, runs = finder.find_path(start, end, grid)
print(find.__name__, runs, len(path))
print(grid.grid_str(path=path, start=start, end=end))
def astar(Matrix, startX, startY, endX, endY): #A* legrovidebb utvonalkereso grid = Grid(matrix = Matrix) start = grid.node(startX, startY) end = grid.node(endX, endY) finder = AStarFinder(diagonal_movement = DiagonalMovement.never) path, runs = finder.find_path(start, end, grid) print(grid.grid_str(path = path, start = start, end = end)) #kirajzolast visszaraktam a szemleletesseg kedveert -T return path
def test_numpy():
"""
test grid from numpy array
"""
matrix = np.array(SIMPLE_MATRIX)
grid = Grid(matrix=matrix)
start = grid.node(0, 0)
end = grid.node(2, 2)
finder = AStarFinder(diagonal_movement=DiagonalMovement.always)
path, runs = finder.find_path(start, end, grid)
assert grid.grid_str(path, start, end) == SIMPLE_WALKED[1:-1]
def pathfind(world, start_x, start_y, end_x, end_y):
"""Find a path from start to end in a world"""
grid = Grid(matrix=world)
start = grid.node(start_x, start_y)
end = grid.node(end_x, end_y)
finder = AStarFinder()
path, runs = finder.find_path(start, end, grid)
return {
'path': path,
'runs': runs,
'render': grid.grid_str(path=path, start=start, end=end)
}
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,
time_limit=TIME_LIMIT)
path, runs = finder.find_path(start, end, grid)
print(find.__name__, runs, len(path))
print(grid.grid_str(path=path, start=start, end=end))
print('path: {}'.format(path))
assert len(path) == scenario['expectedDiagonalLength']
def test():
matrix = [[1, 10, 1, 1, 1], [1, 1, 1, 1, 1], [1, 11, 1, 1, 1, 1],
[1, 1000, 1, 1, 1, 1], [1, 10, 1, 7, 19, 1]]
grid = Grid(matrix=matrix, wrap=True)
start = grid.node(2, 3)
end = grid.node(0, 3)
finder = AStarFinder(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))
def _find(matrix):
grid = Grid(matrix=matrix)
print(matrix)
start = grid.node(0, 0)
end = grid.node(2, 4)
finder = AStarFinder(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))
assert path == [(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 4)]
def a_star(matrix, start, end, cross=False, show=False):
grid = Grid(matrix=matrix)
grid_start = grid.node(start[0], start[1])
grid_end = grid.node(end[0], end[1])
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
if cross:
finder = AStarFinder(diagonal_movement=DiagonalMovement.always)
path, runs = finder.find_path(grid_start, grid_end, grid)
if show:
print('operations:', runs, 'path length:', len(path))
print(grid.grid_str(path=path, start=start, end=end))
return path
def test_path():
"""
test scenarios defined in json file
"""
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(time_limit=TIME_LIMIT)
path, runs = finder.find_path(start, end, grid)
print(find.__name__)
print(grid.grid_str(path=path, start=start, end=end))
print('path: {}'.format(path))
assert len(path) == scenario['expectedLength']
def findPath(start,
end): # Function that queries the pathfinding library for path
global pathMatrix
grid = Grid(matrix=pathMatrix)
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)
print('operations:', runs, 'path length:', len(path))
print(grid.grid_str(path=path, start=start, end=end))
print(path)
return path
def pathfinder(img_array, startpoint, endpoint):
matrix = img_array
grid = Grid(matrix=matrix)
start = grid.node(startpoint[0], startpoint[1])
end = grid.node(endpoint[0], endpoint[1])
finder = AStarFinder(diagonal_movement=DiagonalMovement.always)
path, runs = finder.find_path(start, end, grid)
grid_str = grid.grid_str(path=path, start=start, end=end)
print('operations:', runs, 'path length:', len(path))
print(grid_str)
img_array2 = img_array
for node in path:
col = node[0]
row = node[1]
img_array2[row][col] = 4
img_array2[startpoint[1]][startpoint[0]] = 2
img_array2[endpoint[1]][endpoint[0]] = 3
return img_array2
def pathfinder(matrix, pathfindingfunction, diag_movement):
grid = Grid(matrix=matrix)
start = grid.node(0, 0)
end = grid.node(grid.width - 1, grid.height - 1)
finder = pathfindingfunction(diagonal_movement=diag_movement)
path, runs = finder.find_path(start, end, grid)
print('\n|' + algorithm_string(pathfindingfunction) + '| operations:',
runs, '| path length:', len(path), '|')
print(
grid.grid_str(path=path,
start=start,
end=end,
start_chr=colored('S', 'blue'),
end_chr=colored('E', 'magenta'),
path_chr=colored('x', 'green')))
def findPath(from_v, to_v):
x_f = int(from_v.x)
y_f = int(from_v.y)
x_t = int(to_v.x)
y_t = int(to_v.y)
oldPathFrom = pathMatrix[y_f][x_f]
oldPathTo = pathMatrix[y_t][x_t]
pathMatrix[y_f][x_f] = 1
pathMatrix[y_t][x_t] = 1
gridPath = Grid(matrix=pathMatrix)
start_p = gridPath.node(x_f, y_f)
end = gridPath.node(x_t, y_t)
finder = AStarFinder(
diagonal_movement=DiagonalMovement.if_at_most_one_obstacle)
path, runs = finder.find_path(start_p, end, gridPath)
print(gridPath.grid_str(start=start_p, end=end, path=path))
pathMatrix[y_f][x_f] = oldPathFrom
pathMatrix[y_t][x_t] = oldPathTo
return path
class Obstacle_Grid():
def __init__(self):
# in the end, `self.terrain_grid` will be a 2D array of values where zeros are obstacles
# and all values greater than zero are edge weights for all edges connected to that node
self.terrain_grid = []
with open("./resources/terrain.txt") as input:
rows = input.readlines()
# loop through entire terrain file and convert all chars to integers
for row in rows:
terrain_grid_row = []
for col in row:
if col.isdigit():
terrain_grid_row.append(int(col))
self.terrain_grid.append(terrain_grid_row)
# instantiate the Grid object using the newly converted terrain_grid
# The pathfinding library requires this special object to work
self.grid = Grid(matrix=self.terrain_grid)
# define the A* pathfinding algorithm as the one we use. Another option is Dijkstra's
self.finder = AStarFinder(diagonal_movement=DiagonalMovement.always)
def find_shortest_path(self, location, destination):
"""
Purpose: create a list of spots in a 2D grid that define the shortest path
between two spots
Input: Starting location (`location`) and Ending location (`destination`)
Output: A list of spots/locations in the 2D grid
"""
self.grid.cleanup()
self.start = self.grid.node(location[1], location[0])
self.end = self.grid.node(destination[1], destination[0])
path_list, _ = self.finder.find_path(self.start, self.end, self.grid)
return path_list
def print_path_to_file(self, path_list):
"""
Purpose: Test function that prints the terrain with the shortest path between two nodes
to the console
Input: List of spots in terrain grid that define the shortest path between
two nodes.
Output: None
"""
print(
self.grid.grid_str(path=path_list, start=self.start, end=self.end))
def is_playable(start_end: Dict, room_matrix: List[List[int]], print_path: bool=False) -> bool:
# TODO: invesgate
# if len(start_end) < 2:
# playable = True
# return playable
all_start_end = []
for k in start_end:
all_start_end = all_start_end + start_end[k]
grid = Grid(matrix=room_matrix)
comb = list(combinations(all_start_end, 2))
playable = True
# random.shuffle(comb)
for _start, _end in comb:
# print(_start, _end)
# hardcode here
# if (_start in start_end["D"] and _end in start_end["D"]) or (_start in start_end["S"] and _end in start_end["S"]):
# abs_dis = abs(_start[0] - _end[0]) + abs(_start[1] - _end[1])
# if abs_dis < 4:
# 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 and len(path) > 0:
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 create_waypoints(matrix, y_end, x_end):
coords = [[0, 0], [3.5, 2.5], [3.5, 10.5], [3.5, 22.5], [10.5, 22.5],
[20, 22.5], [34.5, 22.5], [34.5, 12], [34.5, 2.5], [19.5, 2.5],
[19.5, 10.5]]
reversed_test_maze = reverse.reverseZeroOne(matrix)
grid = Grid(matrix=reversed_test_maze)
start = grid.node(0, 0)
end = grid.node(y_end, x_end)
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
print(grid.grid_str(path=path, start=start, end=end))
for i in range(len(path)):
(x, y) = path[i]
path[i] = (y + 0.5, x + 0.5)
return path
def get_instructions(self):
matrix = list(
map(lambda line: list(map(lambda ch: ch == '-', line)), self.maze))
grid = Grid(matrix=matrix)
start = grid.node(*self.start_position)
end = grid.node(*self.end_position)
finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
path, runs = finder.find_path(start, end, grid)
path_len = len(path)
print('>> runs:', runs)
print('>> path length:', path_len)
print('>> path array:', path)
print(grid.grid_str(path=path, start=start, end=end))
instructions = self.path_coord_to_moves(path)
assert (path_len - 1) == len(instructions), len(instructions)
return instructions
def execute_turn(self, gameMap, visiblePlayers):
return create_attack_action(Point(0, -1))
"""This is where you decide what action to take.
:param gameMap: The gamemap.
:param visiblePlayers: The list of visible players."""
x = self.PlayerInfo.Position.x
y = self.PlayerInfo.Position.y
x = x - gameMap.xMin
y = y - gameMap.yMin
matrice = (gameMap.prin()[1]).tolist()
grid = Grid(matrix=matrice)
resources = gameMap.prin()[0]
print(resources)
liste = []
for resource in resources:
print(resource.Position.x, resource.Position.y)
liste.append(resource)
print(liste)
start = grid.node(x, y)
end = grid.node((45 - gameMap.xMin), (8 - gameMap.yMin))
finder = AStarFinder(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))
#Write your bot here. Use functions from aiHelper to instantiate your actions.
a = np.array(path)
print(a)
print(str(np.subtract(a[1], a[0]).tolist()))
return create_move_action(
Point((np.subtract(a[0], a[1]).tolist())[0],
(np.subtract(a[0], a[1]).tolist())[1]))
from pathfinding.core.diagonal_movement import DiagonalMovement
from pathfinding.core.grid import Grid
from pathfinding.finder.a_star import AStarFinder
import ArenaMap
layout = ArenaMap.MazeLayout(
15, 11,
"*#*#*#*#A0507A0604D0206B0001D1302D1000A1307*0003*0303*0405*1107*0600*1104*0705*1317*#"
)
matrix = [[0 for x in range(0, 15)] for y in range(0, 11)]
for y in range(0, 11):
for x in range(0, 15):
if layout.blockedAt(x, y) == True:
matrix[y][x] = 1
grid = Grid(matrix=matrix)
for y in range(0, 11):
print(matrix[y])
start = grid.node(11, 2) # (x,y)
end = grid.node(3, 10)
finder = AStarFinder(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))
def compute_hard_path(map, K):
# First, trim the map down such that it can be divided evenly into K by K square sections.
# Try to keep the trimming as symmetric as possible: If we trim the bottom side, trim the top side next, etc.
H, W = map.shape
K = K
H_excess = H % K
W_excess = W % K
start_x = H_excess / 2
end_x = H - (H_excess / 2)
start_y = W_excess / 2
end_y = W - (W_excess / 2)
# In the event that we only need to trim one edge to make that dimension divisible by K, we have over-adjusted
# in the above code. Rectify that here - is there a simple way to not make that mistake prior?
if (H_excess % 2 == 1):
end_x -= 1
if (W_excess % 2 == 1):
end_y -= 1
map = map[start_x:end_x, start_y:
end_y] # Adjusted map that can now be divided into KxK sections
# Divide the adjusted map into KxK sections, taking the max value of each section to be the value of that
# section.
# We can also take a running total of the number of 1's in each section, to determine which
# sections are least likely to be impassable.
HK = H // K
WK = W // K
weighted_map = (map[:HK * K, :WK * K].reshape(HK, K, WK,
K).sum(axis=(1, 3)))
print 'Weighted reduced map:'
print weighted_map
weighted_map[weighted_map > 0] *= -1
weighted_map[weighted_map == 0] = 1
grid = Grid(matrix=weighted_map)
start = grid.node(2, 0)
end = grid.node(0, 2)
finder = AStarFinder(diagonal_movement=DiagonalMovement.always)
path, runs = finder.find_path(start, end, grid)
path_found = (len(path) != 0)
threshold = 0
while not path_found:
threshold -= 1
weighted_map[weighted_map == threshold] = 1
grid = Grid(matrix=weighted_map)
start = grid.node(2, 0)
end = grid.node(0, 2)
finder = AStarFinder(diagonal_movement=DiagonalMovement.always)
path, runs = finder.find_path(start, end, grid)
path_found = (len(path) != 0)
print(path)
print('operations:', runs, 'path length:', len(path))
print(grid.grid_str(path=path, start=start, end=end))
print 'Highest weight allowed to drive over: ', threshold * -1
adj_path = np.array(path)
adj_path = K * adj_path + (K / 2)
print adj_path
for pt in adj_path[:-1]:
# computeEasyPath(pt, pt + 1, stepSize?????)
print('hey') #placeholder so the red squiggly leaves me alone
return weighted_map
