def accessible_land(self, grid, from_, minx=1, maxx=118, miny=1, maxy=118): """ Returns a random land tile that is accessible from the given tile :Parameters: grid : MapGrid A MapGrid object created from the world map grid fromx : int The x coordinate the tile must be accessible from fromy : int The y coordinate the tile must be accessible from minx : int The minimum x coordinate (default 1) maxx : int The maximum x coordinate (default 118) miny : int The minimum x coordinate (default 1) maxy : int The maximum y coordinate (default 118) rtype: tuple return: An x and y coordinate on the map. """ came_from = {} x = y = 0 while not (x, y) in came_from.keys(): x, y = random.randint(minx, maxx), random.randint(miny, maxy) came_from, cost_so_far = pathfinding.a_star_search( grid, from_, (x, y)) return x, y
def accessible_land(self, grid, from_, minx=1, maxx=118, miny=1, maxy=118): """ Returns a random land tile that is accessible from the given tile :Parameters: grid : MapGrid A MapGrid object created from the world map grid fromx : int The x coordinate the tile must be accessible from fromy : int The y coordinate the tile must be accessible from minx : int The minimum x coordinate (default 1) maxx : int The maximum x coordinate (default 118) miny : int The minimum x coordinate (default 1) maxy : int The maximum y coordinate (default 118) rtype: tuple return: An x and y coordinate on the map. """ came_from = {} x = y = 0 while not (x, y) in came_from.keys(): x, y = random.randint(minx, maxx), random.randint(miny, maxy) came_from, cost_so_far = pathfinding.a_star_search(grid, from_, (x, y)) return x, y
def get_path(the_map): path = pathfinding.a_star_search(the_map, None) if path is None: path = [] #pathfinding.pull_string(the_map, path) return path
def is_accessible(self, grid, from_, to): """ Determines if a particular tile is accessible from another :Parameters: grid : MapGrid A MapGrid object created from the world map grid from : tuple(int) x and y coordinates of the starting point. rtype: bool return: Whether or not the player is able to walk between the 2 coordinates. """ came_from, cost_so_far = pathfinding.a_star_search(grid, from_, to) return to in came_from.keys()
def plot_size(self, grid, point): """ Determines if a particular tile is accessible from another :Parameters: grid : MapGrid A MapGrid object created from the world map grid from_ : tuple(int) x and y coordinates of the starting point. to : tuple(int) x and y coordinates of the ending point. rtype: bool return: Whether or not the player is able to walk between the 2 coordinates. """ came_from, cost_so_far = \ pathfinding.a_star_search(grid, point, (self.map_width, self.map_height)) return len(came_from.keys())
def _update_resource_cell_selected_route_creation(self, op): if op == input_retrieval.CANCEL: self.route_attempts.clear() self.selected = None self.action_desc = "" self.state_type = STANDARD #with resource cell selected, still only recalculate on cursor update if op in input_retrieval.CARDDRS: #Always clear attempts? self.route_attempts.clear() self.action_desc = "" attempted_path_from_start, pathfinding_cost = pathfinding.a_star_search( self.game_map, self.selected.position, self.cursor) if attempted_path_from_start: path_from_start_tiles = [] for pt in attempted_path_from_start: if not self.game_map.get_tile(pt): path_from_start_tiles.append(game_map.RouteAttemptTile(pt)) attempted_start_route = game_map.RouteAttempt( path_from_start_tiles) self.route_attempts.append(attempted_start_route) self.action_desc = "About to create {0:0} route tiles, with cost {1:0} out of available {2:0}. PF Cost {3:0}".format( len(path_from_start_tiles), OUTPOST_CREATION_RESOURCE_COST * len(path_from_start_tiles), self.selected.cluster.get_total_amount(), pathfinding_cost) #print(attempted_path_from_start) if op == input_retrieval.SELECT: #Attempt route creation if len(self.route_attempts): ra = self.route_attempts[0] route_creation_cost = len( ra.attempt_tiles) * OUTPOST_CREATION_RESOURCE_COST if self.selected.cluster.remove_amount(route_creation_cost): for tile in ra.attempt_tiles: outpost = game_map.Outpost(tile.position) self.game_map.outposts.append(outpost) self.game_map.add_tile(outpost, outpost.position) self.route_attempts.clear() self.selected = None self.action_desc = "" self.state_type = STANDARD
def load_map(self, name, entrance_name, display_size): filename = get_map(name) # load data from pytmx tmx_data = load_pygame(filename) # create new data source for pyscroll map_data = pyscroll.data.TiledMapData(tmx_data) # create new renderer (camera) self.map_layer = pyscroll.BufferedRenderer(map_data, display_size, clamp_camera=True, tall_sprites=1) self.map_layer.zoom = 2 # pyscroll supports layered rendering. our map has 3 'under' layers # layers begin with 0, so the layers are 0, 1, and 2. # since we want the sprite to be on top of layer 1, we set the default # layer for sprites as 2 self.group = PyscrollGroup(map_layer=self.map_layer, default_layer=2) # put the hero in tile with name matching entrance_name player_start = tmx_data.get_object_by_name(entrance_name) self._engine.hero.position = [player_start.x, player_start.y] # add our hero to the group self.group.add(self._engine.hero) # setup level geometry with simple pygame rects, loaded from pytmx self.walls = list() self.npcs = list() self.enemies = list() self.triggers = list() temp_npcs = list() # Also a pathfinding grid self.pathfinding_grid = pathfinding.weighted_grid( tmx_data.width, tmx_data.height) for object in tmx_data.objects: if object.type == 'wall': self.walls.append( pygame.Rect(object.x, object.y, object.width, object.height)) # Add walls to the pathfinding grid grid_x = int(object.x / tmx_data.tilewidth) grid_y = int(object.y / tmx_data.tileheight) grid_width = int(object.width / tmx_data.tilewidth) grid_height = int(object.height / tmx_data.tileheight) for y in range(0, grid_height): for x in range(0, grid_width): self.pathfinding_grid.walls.append( (grid_x + x, grid_y + y)) elif object.type == 'npc' or object.type == 'enemy': # Process NPCs and enemies after walls are determined temp_npcs.append(object) elif object.type == 'trigger': self.triggers.append( trigger.trigger(object.x, object.y, object.width, object.height, object.properties)) # Process NPCs and enemies for object in temp_npcs: target_grid_x = int(object.target_x) target_grid_y = int(object.target_y) target_x = target_grid_x * tmx_data.tilewidth target_y = target_grid_y * tmx_data.tileheight origin_grid_x = int(object.x / tmx_data.tilewidth) origin_grid_y = int(object.y / tmx_data.tileheight) # Pathfinding came_from, cost_so_far = pathfinding.a_star_search( self.pathfinding_grid, (origin_grid_x, origin_grid_y), (target_grid_x, target_grid_y)) path = pathfinding.reconstruct_path(came_from, (origin_grid_x, origin_grid_y), (target_grid_x, target_grid_y)) path = [(t[0] * tmx_data.tilewidth, t[1] * tmx_data.tileheight) for t in path] # Load sprite from JSON if object.type == 'npc': npc = character.npc(object.name, path) self.npcs.append(npc) self.group.add(npc) elif object.type == 'enemy': enemy = character.enemy(object.name, path) self.enemies.append(enemy) self.group.add(enemy) # Play background music if 'background_music' in tmx_data.properties: self._engine.play_music(tmx_data.properties['background_music']) # Initialise map self.update(0)
def do_it(start, goal): grid = pf.GridFromImage(_imname_low) start = int(start[0]/_scale), int(start[1]/_scale) goal = int(goal[0]/_scale), int(goal[1]/_scale) came_from1, cost_so_far1 = pf.a_star_search(grid, start, goal) grid.show_path(start, goal, came_from1, _imname_high, _scale, save=True)
import parse import pathfinding import heuristics import resource from pathfinding import a_star_search from solvable_state import fill_solvable from solvable import solvable import sys if __name__ == '__main__': data = parse.get_input() puzzle, size, args = data HEURISTIC = heuristics.H[args.f] y = puzzle.index(0) solved = fill_solvable(size) if solvable(puzzle, size, solved) != 'solvable': print('this puzzle is unsolvable') sys.exit(0) res = a_star_search(puzzle, solved, size, HEURISTIC)