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()
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 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 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(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(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 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 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 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(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 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 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 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 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 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 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 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 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 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 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 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(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 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(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"
class ZombieDriver (Random): ''' The ZombieDriver AI would follow the player relentlessly around without any thought or self preservation mechanism! ''' fire_chance = 3 moving_chance = 80 turning_chance = 5 def __init__(self, world): self.world = world self.map = world.map self.pathfinder = AStarFinder( diagonal_movement=DiagonalMovement.never, time_limit=0.006 ) self.path_cache_duration = 1000 def tick(self, deltat, enemies): interesting_objects = [] for player in self.world.players: if player.tank is None: continue interesting_objects.append((player.tank.rect, 1)) for flag in self.world.un_flags: interesting_objects.append((flag.rect, 1.5)) for enemy in enemies: self.process_enemy(enemy, deltat, interesting_objects) self.fire_at_will(enemy, deltat, interesting_objects) def process_enemy(self, enemy, deltat, interesting_objects): enemy.update_path_duration(deltat) own_coords = enemy.rect own_grid_pos = self.map.world_to_grid_coords(own_coords.centerx, own_coords.centery) if enemy.path_duration <= self.path_cache_duration: self.continue_path(enemy, own_grid_pos) return heat_obj = None heat_weight = 0 for obj, weight in interesting_objects: dist = math.sqrt( abs(own_coords.centerx - obj.centerx) ** 2 + abs(own_coords.centery - obj.centery) ** 2 ) obj_weight = (1 / dist) * weight if obj_weight > heat_weight: heat_weight = obj_weight heat_obj = obj if heat_obj is None: logging.error("ZombieDriver AI finds nothing interesting on the map! How can that be!?") self.do_random_thing(enemy) return hobjx, hobjy = heat_obj.centerx, heat_obj.centery hobj_grid_pos = self.map.world_to_grid_coords(hobjx, hobjy) if hobj_grid_pos == enemy.current_target: enemy.reset_path_duration() self.continue_path(enemy, own_grid_pos) return # WTF!? You have to rebiuld the *whole* grid every time find_path is called! # Definately change to a better library or write A* myself. self.map.build_grid() pf_start = self.map.grid.node(*own_grid_pos) pf_end = self.map.grid.node(*hobj_grid_pos) path, runs = self.pathfinder.find_path( pf_start, pf_end, self.map.grid ) enemy.set_current_path(path) self.continue_path(enemy, own_grid_pos) def fire_at_will(self, enemy, deltat, interesting_objects): if len(enemy.bullets) >= enemy.max_bullets: return for obj, weight in interesting_objects: if not enemy.is_facing(self.map, obj): continue firing_roll = random.randint(0, 100) if firing_roll < self.fire_chance: enemy.fire() def continue_path(self, enemy, grid_pos): next_node = enemy.get_path_next(grid_pos) if next_node is None: self.do_random_thing(enemy) return direction = self.map.grid_direction(grid_pos, next_node) if direction == DIRECTION_NONE: logging.error("For some reason the calculate direction returned NONE after pathfinding") self.do_random_thing(enemy) else: enemy.move(direction)