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