def __init__(self, environment=None): """sets up details about the red rectangle as well as variables for A.I. behavior""" super(RedAiPilot, self).__init__("red_ai_pilot", environment) self.bot = Bot() # set the rectangle's color self.bot.image.fill(RED) # set the starting position self.bot.rect.x = RECTANGLE_STARTING_X self.bot.rect.y = RECTANGLE_STARTING_Y # place the coordinates of our rectangle in a tuple to update the game manager self.red_coordinate = (self.bot.rect.x, self.bot.rect.y) self.rect = self.bot.rect # these coordinates tell the agent how far away the blue player is self.blue_coordinate = None self.distance_from_blue_player = 0 self.current_position = 0 self.path_course = [] self.path_found = False self.next_node_coordinates = None # variables for A.I. behavior self.winning = False self.current_behavior = PilotAgentBehavior.FINDING_PATH self.pathfinder = Pathfinder()
def exec(self, state): self.game = Game(state) self.pathfinder = Pathfinder(self.game) # Choix d'un nouveau client if self.customer is None: print("Selecting customer") _, self.customer_loc = self.pathfinder.get_closest_customer( get_hero_pos(self.game)) self.customer = get_customer_by_pos(self.customer_loc, self.game) if (self.num_death >= 5) and (self.min_heal <= 45): self.min_heal += 5 self.num_death = 0 destination = self.next_state() self.hero_health = get_hero_life(self.game) self.hero_calories = get_our_hero(self.game).calories # Reset de mort et check de healing if self.hero_health == 0: self.num_death += 1 self.next_state = self.init elif (self.hero_calories > 30) and (self.hero_health < self.min_heal): if self.next_state != self.heal: self.state_before_heal = self.next_state self.next_state = self.heal return destination
def main(): pg.init() resolution = (1200, 900) window = pg.display.set_mode(resolution, pg.DOUBLEBUF | pg.RESIZABLE) pg.display.set_caption("pathfinder") map = Terrain(8, 11, 100) # format (y, x) map.set_target([1, 6]) pawn = Pathfinder([6, 6], map.grid) clock = pg.time.Clock() run_flag = True while run_flag: clock.tick(20) for event in pg.event.get(): if event.type == pg.QUIT: run_flag = False if event.type == pg.KEYDOWN: if event.key == pg.K_w: map.add_block_manually(pg.mouse.get_pos()) if event.key == pg.K_e: map.set_target_manually(pg.mouse.get_pos()) if event.key == pg.K_q: map.free_block_manually(pg.mouse.get_pos()) window.fill((120, 120, 120)) map.draw(window) pg.display.update() pawn.make_move(map.grid, window, map)
def __init__(self, arduino=None, android=None, fakeRun=False, fakeMap=None, stepsPerSec=1, **kwargs): """ Constructor. Accepts attributes as kwargs. Args: fakeRun: set True if running simulation. Remember to give fake map as input. I.e: fakeMap = fakemap fakeMap: set simulation map. If left empty, creates an empty arena. pos: a 15x20 array. Contains None, 0 or 1 as values. orientation: Centre of 3x3 start area. Default = [1,1] map: Map object. Refer to Map.py sensors: Sensors object. Refer to sensors.py coordinator: Coordinator object. Refer to coordinator.py """ if fakeRun: self.fakeRun = True from sensors_fake import Sensors self.sensors = Sensors(self, fakeMap) #fake sensors for simulation self.coordinator.fakeRun = True self.coordinator.stepsPerSec = stepsPerSec self.imagefinder = Imagefinder(fakeRun=True) elif arduino is None: raise Exception("Real run requires arduino to be present") elif android is None: raise Exception("Real run requires arduino to be present") else: from sensors import Sensors self.android = android self.sensors = Sensors(self, arduino) self.coordinator.arduino = arduino self.imagefinder = Imagefinder() #update map self.updatemap() goalTiles = [ #set goal as explored [12, 19], [13, 19], [14, 19], [12, 18], [13, 18], [14, 18], [12, 17], [13, 17], [14, 17], ] valuelist = [0] * len(goalTiles) self.map.setTiles(goalTiles, valuelist) #initialise pathfinder self.pathfinder = Pathfinder(self.map) #initialise explorer self.explorer = Explorer(self)
def __init__(self): super().__init__() # Из cfg.txt считывается рабочая директория, # за пределы которой выйти будет нельзя with open('cfg.txt') as f: root = f.readline() # Создается объект, преобразующий ввод в полноценные пути # Он получает на вход рут, и вернет код ошибки, если его покинуть self.pathfinder = Pathfinder(root)
def __init__(self): bot_name = "Swarming" self.game = hlt.Game(bot_name) logging.info("Starting bot {}".format(bot_name)) self.pathfinder = Pathfinder() self.info = Info() self.ai = AI(self.info, self.pathfinder) self.game_map = None
def __init__(self, environment=None): """sets up details about the red rectangle as well as variables for A.I. behavior""" super(NEO, self).__init__("neo", environment) # the bot object represents NEO's physical body # it performs the tasks as directed by the body part classes below self.bot = Bot() # set the bot's image and angle self.bot.image = pygame.Surface([16, 16]) self.bot.image = pygame.transform.scale(pygame.image.load('Neo.png'), (25, 25)) self.original_image = self.bot.image.copy() self.angle = 90 # set the starting position self.bot.rect.x = NEO_STARTING_X self.bot.rect.y = NEO_STARTING_Y # place the coordinates of our rectangle in a tuple to update the game manager self.red_coordinate = (self.bot.rect.x, self.bot.rect.y) self.rect = self.bot.rect # these different body part classes help modularize the various functions NEO performs self.eyes = Eyes() self.hands = Hands() self.legs = Legs() self.memory = Memory() self.memory.create_object_memory() # self.mouth = Mouth() # self.ears = Ears() self.wernicke_area = Wernicke_Area() self.current_object = None # these coordinates tell the agent how far away the object is self.object_coordinates = None self.distance_from_object = 0 self.current_position = 0 self.path_course = [] self.path_found = False self.next_node_coordinates = None # variables for A.I. behavior self.inspecting = False self.detected_objects = [] self.uninspected_objects = [] self.current_behavior = BEHAVIOR_STATE.SCANNING self.pathfinder = Pathfinder() self.running_training = True #search variables self.rotating_counter = 0 self.location_coordinates = self.ask("memory", "location_coordinates") self.sql_statement = None
def __init__(self): # INIT PYGAME pygame.init() pygame.display.set_caption("A* demo") pygame.font.init() self.font = pygame.font.SysFont("roboto", 25) self.is_running = False self.started = False self.screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT)) self.pencil = BlockType.WALL self.board = Board(WINDOW_WIDTH, WINDOW_HEIGHT - 120, BLOCK_SIZE) self.finder = Pathfinder(self.board)
def __init__(self, id, pos, app): Tank.__init__(self, id, pos, app) self.path = None self.dest = (10,10) self.idest = None self.rot_dest = None self.rotation_signum = 0 self.driving_signum = 0 self.previous_state = None self.pathfinder = Pathfinder(self.is_valid_cell) dx, dy = self.dest dcell = self.app.current_map.get_at_pixel(dx, dy) x,y = self.position cell = self.app.current_map.get_at_pixel(x, y) self.pathfinder.setupPath(cell.i, cell.j, dcell.i, dcell.j)
def createboard(self, predefinedboard, uselastdata): """ Create board and prepares paths if not prepared. :param predefinedboard: Array of sprites :param uselastdata: Bool value determining if paths have already been calculated. :return: nothing """ Board(predefinedboard, self.systems, self.elements, self.tile_size) start = int(round(time.time() * 1000)) if not uselastdata: self.last_data = Pathfinder(predefinedboard) self.last_data.prepareallstepsforshortestpaths() print("Pathfinder time: ", int(round(time.time() * 1000)) - start) self.systems[AiMovementSystem.NAME].register(self.last_data) self.elements.append(self.last_data)
def __init__(self, window, algorithm): self.window = window self.score = 0 self.snake = [Snake(window.display, (WIDTH/2, HEIGHT/2))] self.apple = Apple(window.display, self.snake) # make graph self.graph = Environment(self.snake, self.apple) # init search algorithm self.algorithm = Pathfinder( self.snake[0].relative_pos, self.apple.relative_pos, self.graph, algorithm) # Run loop self.loop() self.window.quit()
def test_astar_intercardinal_search(self): map = [ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 2, 0], [0, 0, 1, 1, 1, 0, 0, 2, 0, 0], [0, 0, 0, 1, 1, 0, 2, 0, 0, 2], [0, 0, 0, 0, 1, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ] # Make it walkable only on tiles with a 2 walkable = lambda v: v != 2 # We need to annotate the clearance on the grid for later use in our pathfindings grid = Grid(map).annotate(walkable) finder = Pathfinder(astar.search) agent_characteristics = AgentCharacteristics(walkable=walkable, clearance=2) path = finder.get_path( grid, (0, 0), (8, 8), agent_characteristics=agent_characteristics, heuristic=cardinal_intercardinal, ) X = "x" marked_map = [ [X, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, X, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, X, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, X, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, X, 0, 0, 0, 2, 0], [0, 0, 1, 1, X, 0, 0, 2, 0, 0], [0, 0, 0, 1, 1, X, 2, 0, 0, 2], [0, 0, 0, 0, 1, 0, X, X, 0, 2], [0, 0, 0, 0, 0, 0, 0, 0, X, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ] self._assert_the_resulting_path_nodes_should_be_like(marked_map, path)
def test_do_a_search_smaller_corridor(self): map = [ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 2, 0, 0, 0, 0, 0, 0, 0, 0], [0, 2, 0, 1, 0, 0, 0, 0, 0, 0], [0, 2, 1, 0, 0, 0, 0, 0, 2, 0], [0, 2, 1, 1, 1, 0, 0, 2, 0, 0], [0, 2, 0, 1, 1, 0, 2, 0, 0, 2], [0, 2, 0, 0, 1, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ] walkable = lambda v: v != 2 grid = Grid(map).annotate(walkable) finder = Pathfinder(astar.search) startx, starty = 0, 0 endx, endy = 0, 8 agent_characteristics = AgentCharacteristics(walkable=walkable, clearance=2) path = finder.get_path( grid, (startx, starty), (endx, endy), agent_characteristics, heuristic=heuristics.diagonal, ) X = "x" marked_map = [ [X, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, X, 0, 0, 0, 0, 0, 0, 1, 0], [0, 2, X, 0, 0, 0, 0, 0, 0, 0], [0, 2, X, 1, 0, 0, 0, 0, 0, 0], [0, 2, X, 0, 0, 0, 0, 0, 2, 0], [0, 2, X, 1, 1, 0, 0, 2, 0, 0], [0, 2, X, 1, 1, 0, 2, 0, 0, 2], [0, 2, X, 0, 1, 0, 0, 0, 0, 2], [X, X, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ] self._assert_the_resulting_path_nodes_should_be_like(marked_map, path)
def test_astar_large_map(self, datadir): # Make it walkable only if walkable = lambda v: v != 2 map = (datadir / "large_map_hard.map").read_text() map = map.replace("@", "2").replace("T", "1").replace(".", "0") grid = Grid(map).annotate(walkable) finder = Pathfinder(astar.search) agent_characteristics = AgentCharacteristics(walkable=walkable, clearance=2) finder.get_path( grid, (0, 0), (8, 8), agent_characteristics, heuristic=cardinal_intercardinal, )
def test_paths(self): """ Confirms each waypoint is reachable """ for z in range(self.dim_z+1): # Create the graph, impediments are walls(0) and locked doors(L) imp = [] this_floor = [None for y in range(self.dim_y)] for y in range(self.dim_y): this_floor[y]=[None for x in range(self.dim_x)] for x in range(self.dim_x): this_floor[y][x]=self.grid[x,y,z][0] graph = GraphGrid(this_floor) # Default impediments are wall(0) and locked doors(L) imp=[(a,b) for a,b,c in self.grid if self.grid[a,b,z][0] in [0,'0','L']] # Set the list of impassable points graph.impassable = imp # Set the floor start and end points start,end = self.find_path_ends(z) self.logger.info('[*] Testing the path from {} to {}'.format(start, end)) # Initialize the path tester, as a_star for best path path_tester=Pathfinder(Pathfinder.gb_first) path_tester.g = graph path_tester.start = start[:2] path_tester.dest = end[:2] path = path_tester.execute() if not path: self.logger.error("Invalid pathfinding algorithm") else: for (x,y) in path: val=path[x,y] if val is not None: if self.grid[x,y,z][0] not in ['U','D','S','E']: self.grid[val[0],val[1],z][1]=[color.WHITE_ON_BLUE]
def test_astar_all_heuristics_should_return_a_similar_path(self, all_heuristics): map = [ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 2, 0], [0, 0, 1, 1, 1, 0, 0, 2, 0, 0], [0, 0, 0, 1, 1, 0, 2, 0, 0, 2], [0, 0, 0, 0, 1, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ] walkable = lambda v: v != 2 grid = Grid(map).annotate(walkable) finder = Pathfinder(astar.search) startx, starty = 0, 0 endx, endy = 8, 8 paths = [] agent_characteristics = AgentCharacteristics(walkable=walkable, clearance=2) for heuristic in all_heuristics: paths.append( finder.get_path( grid, (startx, starty), (endx, endy), agent_characteristics, heuristic=heuristic, ) ) num_nodes = len(paths[0].nodes) assert all(len(path.nodes) == num_nodes for path in paths)
def find_path(): if request.method == 'POST': pathfinder = Pathfinder(host='localhost', port='5436', database='postgres', user='******', password='******') data = json.loads(request.data.decode('ascii')) start = data['viewparams']['start'] end = data['viewparams']['end'] time_limit = data['time'] # hours distance_limit = data['distance'] # km time_start = time.time() # Uruchomienie procedury podstawowej - procedura RUN pathfinder.run(start, end, distance_limit * 1000, time_limit) time_end = time.time() print('Total time (in minutes): {}'.format((time_end - time_start)/60.0)) print('Number of locations: {}'.format(len(pathfinder.locations))) print('Additional len left: {}'.format(pathfinder.additional_len)) print('Additional time left: {}'.format(pathfinder.additional_time)) # Sprawdzenie, czy zostalo wykorzystane co najmniej 80% dodatkowych kilometrow if pathfinder.additional_len / float(distance_limit * 1000) <= 0.2 or pathfinder.additional_len <= 2000: ret = { 'key_points': pathfinder.locations, 'route': pathfinder.routes } return jsonify(ret) # Let's try again print('Trying one more time') locations_backup = pathfinder.locations routes_backup = pathfinder.routes time_start = time.time() # Uruchomienie procedury wyjatkowej - procedura RUN_WITH_FIRST_RANDOM pathfinder.run_with_first_random(start, end, distance_limit * 1000, time_limit) time_end = time.time() print('Total time (in minutes): {}'.format((time_end - time_start)/60.0)) print('Number of locations: {}'.format(len(pathfinder.locations))) print('Additional len left: {}'.format(pathfinder.additional_len)) print('Additional time left: {}'.format(pathfinder.additional_time)) if len(pathfinder.locations) > len(locations_backup): ret = { 'key_points': pathfinder.locations, 'route': pathfinder.routes } return jsonify(ret) else: ret = { 'key_points': locations_backup, 'route': routes_backup } return jsonify(ret)
async def run_async_2(): with timewith("async"): grid = Grid(map) finder = Pathfinder(astar.search, heuristic=cardinal_intercardinal) grid.annotate(walkable) get_path_async = async_wrap(finder.get_path) # Compute all the paths serially computed_paths = [] tasks = [] for start, end in paths: tasks.append( get_path_async(start[0], start[1], end[0], end[1], agent_size)) await aio.gather(*tasks) assert len(computed_paths) == len(paths)
def __init__(self, cutDiameter, mowerLength, turnRadius, centerDistance, length, width, startingIndex): self.client = MongoClient() self.db = self.client.backyardbarber self.collection = self.db.schedules self.finder = Pathfinder(cutDiameter, mowerLength, turnRadius, centerDistance, length, width) self.cutDiameter = cutDiameter self.mowerLength = mowerLength self.turnRadius = turnRadius self.centerDistance = centerDistance self.length = length self.width = width self.pathBuilt = (self.db.path.find().count > 0) if Controller.coms is None: Controller.coms = Communications(0) if Controller.running is None: Controller.running = False if Controller.controller is None: Controller.controller = self
def __init__(self, game_map, ships): self.game_map = game_map self.id = min(ships) self.ships = ships self.vel_x = 0 self.vel_y = 0 self.magnitude = 0 self.angle = 0 self.target = None self.formation = 'ender' self.focus = None self.radius = None self.pathfinder = Pathfinder() self.position_modifier = [] if self.formation == 'ender': self.inner_ring_distance = 0.5 * 2 + SQUADRON_SPREAD self.outer_ring_distance = 0.5 * 4 + SQUADRON_SPREAD * 2 self.position_modifier.append((0, 0)) for angle in range(0, 360, 60): self.position_modifier.append( (self.inner_ring_distance, angle)) for angle in range(0, 360, 30): self.position_modifier.append( (self.outer_ring_distance, angle)) self.max_size = 19 if self.formation == '3': self.distance_between_ships = 0.5 * 2 + SQUADRON_SPREAD self.max_size = 3 for ship in self.ships: self.game_map.get_me().get_ship(ship).in_squadron = True self.distance_between_ships = 0.5 * 2 + SQUADRON_SPREAD self.update_position() self.x, self.y = self.get_center_point(self.ships)
def __init__(self, width, height, tile_side_length): self.start_tile = None self.finish_tile = None self.width = width self.height = height self.tiles = [height * [0] for _ in range(width)] self.tiles_unordered = [] self.tile_images = pygame.sprite.Group() for x in range(width): for y in range(height): self.tiles[x][y] = Tile(x * tile_side_length, y * tile_side_length, tile_side_length) for col in self.tiles: for tile in col: self.tile_images.add(tile.sprite) self.tiles_unordered += [tile] self.establish_connections() self.pathfinder = Pathfinder(self.tiles_unordered, self.start_tile, self.finish_tile)
def test_paths(self): """ Confirms each waypoint is reachable """ for z in range(self.dim_z + 1): # Create the graph, impediments are walls(0) and locked doors(L) imp = [] this_floor = [None for y in range(self.dim_y)] for y in range(self.dim_y): this_floor[y] = [None for x in range(self.dim_x)] for x in range(self.dim_x): this_floor[y][x] = self.grid[x, y, z][0] graph = GraphGrid(this_floor) # Default impediments are wall(0) and locked doors(L) imp = [(a, b) for a, b, c in self.grid if self.grid[a, b, z][0] in [0, '0', 'L']] # Set the list of impassable points graph.impassable = imp # Set the floor start and end points start, end = self.find_path_ends(z) self.logger.info('[*] Testing the path from {} to {}'.format( start, end)) # Initialize the path tester, as a_star for best path path_tester = Pathfinder(Pathfinder.gb_first) path_tester.g = graph path_tester.start = start[:2] path_tester.dest = end[:2] path = path_tester.execute() if not path: self.logger.error("Invalid pathfinding algorithm") else: for (x, y) in path: val = path[x, y] if val is not None: if self.grid[x, y, z][0] not in ['U', 'D', 'S', 'E']: self.grid[val[0], val[1], z][1] = [color.WHITE_ON_BLUE]
class NEO(Agent): """Controls the behaviors of the NEO bot NEO has four main tasks: 1. scan the room for new objects, 2. approach discovered objects, 3. inspect objects and gather info about their attributes, 4. accept queries from the user to test its memory of objects. NEO performs these tasks by using the various body part classes located in the neo_body directory. This NEO class essentially serves as the 'brain' class and passes commands to all other body parts as needed. NEO and every body part class are subclasses of the Agent class, which allows them to safely share info with each other using Agent Oriented Programming methods. This allows us to easily add new parts or replace parts altogether.""" def __init__(self, environment=None): """sets up details about the red rectangle as well as variables for A.I. behavior""" super(NEO, self).__init__("neo", environment) # the bot object represents NEO's physical body # it performs the tasks as directed by the body part classes below self.bot = Bot() # set the bot's image and angle self.bot.image = pygame.Surface([16, 16]) self.bot.image = pygame.transform.scale(pygame.image.load('Neo.png'), (25, 25)) self.original_image = self.bot.image.copy() self.angle = 90 # set the starting position self.bot.rect.x = NEO_STARTING_X self.bot.rect.y = NEO_STARTING_Y # place the coordinates of our rectangle in a tuple to update the game manager self.red_coordinate = (self.bot.rect.x, self.bot.rect.y) self.rect = self.bot.rect # these different body part classes help modularize the various functions NEO performs self.eyes = Eyes() self.hands = Hands() self.legs = Legs() self.memory = Memory() self.memory.create_object_memory() # self.mouth = Mouth() # self.ears = Ears() self.wernicke_area = Wernicke_Area() self.current_object = None # these coordinates tell the agent how far away the object is self.object_coordinates = None self.distance_from_object = 0 self.current_position = 0 self.path_course = [] self.path_found = False self.next_node_coordinates = None # variables for A.I. behavior self.inspecting = False self.detected_objects = [] self.uninspected_objects = [] self.current_behavior = BEHAVIOR_STATE.SCANNING self.pathfinder = Pathfinder() self.running_training = True #search variables self.rotating_counter = 0 self.location_coordinates = self.ask("memory", "location_coordinates") self.sql_statement = None def act_out_decision(self): pass def check_distance_from_object(self): self.update_coordinates() self.distance_from_object = \ abs(self.object_coordinates[0] - self.red_coordinate[0]) + \ abs(self.object_coordinates[1] - self.red_coordinate[1]) def determine_behavior(self): if self.inspecting: self.current_behavior = BEHAVIOR_STATE.INSPECTING elif self.uninspected_objects and not self.path_found: self.current_behavior = BEHAVIOR_STATE.PATH_FINDING self.current_object = self.uninspected_objects[0] elif self.path_found: self.current_behavior = BEHAVIOR_STATE.APPROACHING else: self.current_behavior = BEHAVIOR_STATE.SCANNING def determine_object_position(self): """"used to determine which direction the red player should turn to face object""" if self.red_coordinate[0] + MARGIN >= self.object_coordinates[ 0] >= MARGIN - self.red_coordinate[0]: # red player is above blue player if self.red_coordinate[1] < self.object_coordinates[1] - MARGIN: self.current_position = PilotCurrentPosition.ABOVE # red player is below blue player elif self.red_coordinate[1] > self.object_coordinates[1] + MARGIN: self.current_position = PilotCurrentPosition.BELOW # red player is right of blue elif self.red_coordinate[0] > self.object_coordinates[0]: self.current_position = PilotCurrentPosition.RIGHT # red player is left of blue elif self.red_coordinate[0] < self.object_coordinates[0]: self.current_position = PilotCurrentPosition.LEFT def filter_detected_objects(self): """Decides whether detected objects(currently just 1 at a time) have been inspected before""" for obj in self.detected_objects: self.sql_statement = "SELECT * FROM objects WHERE object_x_pos = " + str(obj.x) + \ " AND object_y_pos = " + str(obj.y) self.memory.recall_objects() if self.ask("memory", "short_term_memory"): self.detected_objects.remove(obj) else: self.uninspected_objects += [obj] self.detected_objects.remove(obj) def find_next_node(self): """finds the closest node in our path and removes nodes once they are reached""" if not (1 <= abs(self.rect.centerx - self.next_node_coordinates[0]) or 1 <= abs(self.rect.centery - self.next_node_coordinates[1])): self.path_course.pop(0) if self.path_course: self.next_node_coordinates = (self.path_course[0].x, self.path_course[0].y) def is_healthy(self): return self.hit_points > 50 def make_decision(self): """Acts out decisions based on the current behavior state""" if not self.running_training: self.filter_detected_objects() self.determine_behavior() if self.current_behavior == BEHAVIOR_STATE.SCANNING: self.legs.rotate() self.angle = self.ask("legs", "angle") self.eyes.scan_room() # _thread.start_new_thread(self.mouth.speak, ("Scanning Room",)) elif self.current_behavior == BEHAVIOR_STATE.PATH_FINDING: self.path_course = self.pathfinder.find_path( self.object_coordinates) self.path_found = True self.next_node_coordinates = (self.path_course[0].x, self.path_course[0].y) elif self.current_behavior == BEHAVIOR_STATE.APPROACHING: if not self.path_course: self.path_found = False self.inspecting = True return self.find_next_node() self.move_to_next_node() elif self.current_behavior == BEHAVIOR_STATE.INSPECTING: # if not self.mouth.inspection_message_spoken: # self.mouth.stopSentence() # _thread.start_new_thread(self.mouth.speak, ("Inspecting Object",)) # self.mouth.inspection_message_spoken = True self.eyes.look_at_object() self.hands.pick_up_object() self.memory.memorize() self.inspecting = False self.uninspected_objects.remove(self.current_object) self.current_object = None else: self.run_training() def move_to_next_node(self): """tells the bot which direction to move to reach the next node in its path""" if self.next_node_coordinates[0] < self.rect.centerx: self.bot.move(-2, 0) elif self.next_node_coordinates[0] > self.rect.centerx: self.bot.move(2, 0) # up and down if self.next_node_coordinates[1] < self.rect.centery: self.bot.move(0, -2) elif self.next_node_coordinates[1] > self.rect.centery: self.bot.move(0, 2) # def rotate(self): Use the one in legs.py instead # self.angle += .5 # key = pygame.key.get_pressed() # if key[pygame.K_LEFT]: # self.angle += 4 # if key[pygame.K_RIGHT]: # self.angle -= 4 # # self.angle += 2 # self.angle %= 360 # self.bot.angle_facing = self.angle # self.bot.update_dx_dy() # # rect_center = self.bot.image.get_rect() # self.bot.image = pygame.transform.rotozoom(self.original_image, self.angle, 1) # rot_rect = rect_center.copy() # rot_rect.center = self.bot.image.get_rect().center # self.bot.image = self.bot.image.subsurface(rot_rect).copy() def run_training(self): if self.current_behavior != BEHAVIOR_STATE.PATH_FINDING: key = pygame.key.get_pressed() if key[pygame.K_LEFT]: self.legs.walk(-2, 0) if key[pygame.K_RIGHT]: self.legs.walk(2, 0) if key[pygame.K_UP]: self.legs.walk(0, -2) if key[pygame.K_DOWN]: self.legs.walk(0, 2) if key[pygame.K_SPACE]: location_name = input("Enter a name for this location:") self.memory.save_location(location_name) if key[pygame.K_c]: command = input("Enter a command to run") self.wernicke_area.parse_command(command) # location_coordinates = self.ask("wernicke_area", "location_coordinates") self.update_coordinates() self.current_behavior = self.ask("wernicke_area", "next_behavior") self.current_behavior = BEHAVIOR_STATE(7) # to do: add division between tasks # self.path_course = self.pathfinder.find_path(location_coordinates) # self.current_behavior = BEHAVIOR_STATE.PATH_FINDING # print(self.path_course) elif self.current_behavior == BEHAVIOR_STATE.PATH_FINDING: if not self.path_course: self.path_found = False self.current_behavior = BEHAVIOR_STATE.TRAINING return else: self.next_node_coordinates = (self.path_course[0].x, self.path_course[0].y) self.find_next_node() self.move_to_next_node() def search_for(self): self.legs.rotate() self.rotating_counter += 1 self.angle = self.ask("legs", "angle") if self.rotating_counter > 360: self.rotating_counter = 0 self.current_behavior = BEHAVIOR_STATE.SWITCHING_ROOMS else: self.eyes.scan_room() self.current_behavior = BEHAVIOR_STATE.SEARCHING def update_search(self): if self.current_behavior == BEHAVIOR_STATE.SEARCHING: self.search_for() elif self.current_behavior == BEHAVIOR_STATE.SWITCHING_ROOMS: self.go_to_room() def go_to_room(self): if self.path_course is None: self.path_course = self.pathfinder.find_path( self.location_coordinates[0]) self.location_coordinates.pop(0) else: self.next_node_coordinates = (self.path_course[0].x, self.path_course[0].y) self.move_to_next_node() def setup_bot_map(self): self.bot.wall_list = self.environment.get_object("wall_list") def shoot(self): if self.bot.reloaded(): bullet_list = self.environment.get_object("bullet_list") if self.current_position == PilotCurrentPosition.LEFT: bullet_list.add(self.bot.shoot_right()) elif self.current_position == PilotCurrentPosition.RIGHT: bullet_list.add(self.bot.shoot_left()) elif self.current_position == PilotCurrentPosition.ABOVE: bullet_list.add(self.bot.shoot_down()) elif self.current_position == PilotCurrentPosition.BELOW: bullet_list.add(self.bot.shoot_up()) def update_coordinates(self): self.red_coordinate = (self.rect.x, self.rect.y)
import socket import json from pathfinder import Pathfinder import time server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.bind(("172.16.17.26", 8090)) server.listen(1) robot = Pathfinder() client, addr = server.accept() client.settimeout(2) try: while True: msg = client.recv(1024) if msg == "quit": break else: try: msg = json.loads(msg) robot.move(msg['x'], msg['y'], msg['w'],) except ValueError: pass except socket.timeout: print("timeout error") robot.move(0,0,0) except socket.error: print("socket error occured: ") robot.move(0,0,0) server.close()
class Controller(): coms = None running = None controller = None def __init__(self, cutDiameter, mowerLength, turnRadius, centerDistance, length, width, startingIndex): self.client = MongoClient() self.db = self.client.backyardbarber self.collection = self.db.schedules self.finder = Pathfinder(cutDiameter, mowerLength, turnRadius, centerDistance, length, width) self.cutDiameter = cutDiameter self.mowerLength = mowerLength self.turnRadius = turnRadius self.centerDistance = centerDistance self.length = length self.width = width self.pathBuilt = (self.db.path.find().count > 0) if Controller.coms is None: Controller.coms = Communications(0) if Controller.running is None: Controller.running = False if Controller.controller is None: Controller.controller = self def buildPath(self): self.finder.buildBasePath() self.pathBuilt = True def startMower(self): if self.pathBuilt == False: self.buildPath() if Controller.running == False: Controller.coms.run() Controller.running = True # tell node that we started def interrupt(self, message, terminate): Controller.coms.interrupt(message, terminate) Controller.running = False def schedule(self): cron = CronTab() for schedule in self.collection.find(): job = cron.new(command='python /backyarbarber/python/controller.py startMower') min = schedule["time"]["minute"] hour = schedule["time"]["hour"] days = schedule["days"] dayString = "" if days["Sunday"]: dayString += ",0" elif days["Monday"]: dayString += ",1" elif days["Tuesday"]: dayString += ",2" elif days["Wednesday"]: dayString += ",3" elif days["Thursday"]: dayString += ",4" elif days["Friday"]: dayString += ",5" elif days["Saturay"]: dayString += ",6" if dayString[0] == ',': dayString = dayString[1:] job.minute.on(min) job.hour.on(hour) job.days.on(dayString) job.enable()
class SimpleBot(Bot): def __init__(self): self.customer = None self.customer_loc = None self.game = None self.next_state = self.init self.state_before_heal = self.init self.fries_loc = None self.burger_loc = None self.drink_loc = None self.pathfinder = None self.min_heal = 30 self.num_death = 0 self.hero_health = 100 self.hero_calories = 0 def init(self): self.next_state = self.get_fries self.state_before_heal = self.get_fries self.customer = None self.customer_loc = None self.fries_loc = None self.drink_loc = None self.pathfinder = None return 'Stay' def exec(self, state): self.game = Game(state) self.pathfinder = Pathfinder(self.game) # Choix d'un nouveau client if self.customer is None: print("Selecting customer") _, self.customer_loc = self.pathfinder.get_closest_customer( get_hero_pos(self.game)) self.customer = get_customer_by_pos(self.customer_loc, self.game) if (self.num_death >= 5) and (self.min_heal <= 45): self.min_heal += 5 self.num_death = 0 destination = self.next_state() self.hero_health = get_hero_life(self.game) self.hero_calories = get_our_hero(self.game).calories # Reset de mort et check de healing if self.hero_health == 0: self.num_death += 1 self.next_state = self.init elif (self.hero_calories > 30) and (self.hero_health < self.min_heal): if self.next_state != self.heal: self.state_before_heal = self.next_state self.next_state = self.heal return destination def get_fries(self): if self.fries_loc is None: print("Choosing new fries") fries_tile, self.fries_loc = self.pathfinder.get_closest_fries( get_hero_pos(self.game)) client_fries = self.customer.french_fries hero_fries = get_hero_fries(self.game) direction = get_direction(self.game, self.fries_loc) hero_loc = get_hero_pos(self.game) if self.pathfinder.get_distance(self.fries_loc, hero_loc) <= 1: print("Fries acquired") self.fries_loc = None if hero_fries >= client_fries: self.next_state = self.get_burgers else: self.next_state = self.get_fries return direction def get_burgers(self): if self.burger_loc is None: print("Choosing new burger") burger_tile, self.burger_loc = \ self.pathfinder.get_closest_burger(get_hero_pos(self.game)) client_burgers = self.customer.burger hero_burgers = get_hero_burgers(self.game) hero_loc = get_hero_pos(self.game) direction = get_direction(self.game, self.burger_loc) if self.pathfinder.get_distance(self.burger_loc, hero_loc) <= 1: print("Burger acquired") self.burger_loc = None if hero_burgers >= client_burgers: if get_hero_fries(self.game) >= self.customer.french_fries: self.next_state = self.goto_customer else: self.next_state = self.get_fries else: self.next_state = self.get_burgers return direction def heal(self): # Check si on a les calories pour guerir if self.hero_calories <= 30: self.next_state = self.state_before_heal return 'STAY' hero_loc = get_hero_pos(self.game) if self.drink_loc is None: drink_tile, self.drink_loc = self.pathfinder.get_closest_drink( hero_loc) direction = get_direction(self.game, self.drink_loc) print("Healing time! drink pos: {}".format(self.drink_loc)) if (self.pathfinder.get_distance(self.drink_loc, hero_loc) <= 1) \ or (self.hero_health == 100): print("drink acquired") self.drink_loc = None self.min_heal -= (100 - self.hero_health) if self.min_heal < 30: self.min_heal = 30 self.next_state = self.state_before_heal return direction def goto_customer(self): direction = get_direction(self.game, self.customer_loc) hero_loc = get_hero_pos(self.game) if self.pathfinder.get_distance(self.customer_loc, hero_loc) <= 1: self.customer = None self.customer_loc = None self.next_state = self.get_fries return direction def opportunity(self): direction = self.check_for_opportunity('Stay') # Transition d'etat if get_hero_fries(self.game) < self.customer.french_fries: self.next_state = self.get_fries elif get_hero_burgers(self.game): self.next_state = self.get_burgers else: self.next_state = self.goto_customer # Retourne mouvement if direction: return direction else: return 'Stay' def check_for_opportunity(self, direction): cardinal_directions = ['WEST', 'EAST', 'NORTH', 'SOUTH'] hero_loc = get_hero_pos(self.game) for dir in cardinal_directions: destination = self.game.board.to(hero_loc, direction) row, col = destination tile = self.game.board.tiles[row][col] print("Direction choisi: {} -- opportunite: {}".format( type(direction), type(dir))) if direction != dir and (isinstance(tile, FriesTile) or isinstance(tile, BurgerTile)): owner_id = tile.hero_id if owner_id == '-': owner_id = '-1' if int(owner_id) != get_our_hero_id(self.game): return dir
def main() -> None: drawing = """ ##### #..E# #...# #...# #S#.# #.#.# ##### """.strip() maze = Maze(drawing) # pf = Pathfinder(maze) # pf.show() start = Point(x=1, y=4) end = Point(x=3, y=1) pf.set_start_point(start) pf.set_end_point(end) # pf.show_maze_with_distance_values() pf.start_bfs_discovery() pf.show_maze_with_distance_values() path = pf.find_shortest_path() print(path)
class RedAiPilot(Agent): """Controls the behaviors of the red rectangle in the game RedAiPilot's decisions are based on its current_behavior state. The state is determined by the conditions of its environment. A full list of behaviors can be found at the bottom of the red_ai_pilot module in the PilotAgentBehavior class.""" def __init__(self, environment=None): """sets up details about the red rectangle as well as variables for A.I. behavior""" super(RedAiPilot, self).__init__("red_ai_pilot", environment) self.bot = Bot() # set the rectangle's color self.bot.image.fill(RED) # set the starting position self.bot.rect.x = RECTANGLE_STARTING_X self.bot.rect.y = RECTANGLE_STARTING_Y # place the coordinates of our rectangle in a tuple to update the game manager self.red_coordinate = (self.bot.rect.x, self.bot.rect.y) self.rect = self.bot.rect # these coordinates tell the agent how far away the blue player is self.blue_coordinate = None self.distance_from_blue_player = 0 self.current_position = 0 self.path_course = [] self.path_found = False self.next_node_coordinates = None # variables for A.I. behavior self.winning = False self.current_behavior = PilotAgentBehavior.FINDING_PATH self.pathfinder = Pathfinder() def act_out_decision(self): if self.current_behavior == PilotAgentBehavior.FINDING_PATH: self.path_course = self.pathfinder.find_path(self.blue_coordinate) self.path_found = True self.next_node_coordinates = (self.path_course[0].x, self.path_course[0].y) if self.current_behavior == PilotAgentBehavior.CHASING: if not self.path_course: self.path_found = False return self.find_next_node() self.move_to_next_node() if self.current_behavior is PilotAgentBehavior.SHOOTING: self.determine_enemy_position() self.shoot() def check_distance_from_opponent(self): self.update_coordinates() self.distance_from_blue_player = \ abs(self.blue_coordinate[0] - self.red_coordinate[0]) + abs(self.blue_coordinate[1] - self.red_coordinate[1]) def determine_behavior(self): self.check_distance_from_opponent() if self.distance_from_blue_player > 100 and self.bot.hit_points > 50: if not self.path_found: self.current_behavior = PilotAgentBehavior.FINDING_PATH else: self.current_behavior = PilotAgentBehavior.CHASING elif self.bot.hit_points > 50: self.current_behavior = PilotAgentBehavior.SHOOTING else: self.current_behavior = PilotAgentBehavior.FLEEING def determine_enemy_position(self): if self.red_coordinate[0] + MARGIN >= self.blue_coordinate[ 0] >= MARGIN - self.red_coordinate[0]: # red player is above blue player if self.red_coordinate[1] < self.blue_coordinate[1] - MARGIN: self.current_position = PilotCurrentPosition.ABOVE # red player is below blue player elif self.red_coordinate[1] > self.blue_coordinate[1] + MARGIN: self.current_position = PilotCurrentPosition.BELOW elif self.red_coordinate[0] > self.blue_coordinate[0]: self.current_position = PilotCurrentPosition.RIGHT elif self.red_coordinate[0] < self.blue_coordinate[0]: self.current_position = PilotCurrentPosition.LEFT def find_next_node(self): if not (1 <= abs(self.rect.centerx - self.next_node_coordinates[0]) or 1 <= abs(self.rect.centery - self.next_node_coordinates[1])): self.path_course.pop(0) if self.path_course: self.next_node_coordinates = (self.path_course[0].x, self.path_course[0].y) def is_healthy(self): return self.hit_points > 50 def make_decision(self): self.determine_behavior() self.act_out_decision() def move_to_next_node(self): if self.next_node_coordinates[0] < self.rect.centerx: self.bot.move(-2, 0) elif self.next_node_coordinates[0] > self.rect.centerx: self.bot.move(2, 0) # up and down if self.next_node_coordinates[1] < self.rect.centery: self.bot.move(0, -2) elif self.next_node_coordinates[1] > self.rect.centery: self.bot.move(0, 2) def setup_bot_map(self): self.bot.wall_list = self.environment.get_object("wall_list") def shoot(self): if self.bot.reloaded(): bullet_list = self.environment.get_object("bullet_list") if self.current_position == PilotCurrentPosition.LEFT: bullet_list.add(self.bot.shoot_right()) elif self.current_position == PilotCurrentPosition.RIGHT: bullet_list.add(self.bot.shoot_left()) elif self.current_position == PilotCurrentPosition.ABOVE: bullet_list.add(self.bot.shoot_down()) elif self.current_position == PilotCurrentPosition.BELOW: bullet_list.add(self.bot.shoot_up()) def update_coordinates(self): self.red_coordinate = (self.rect.x, self.rect.y) self.blue_coordinate = self.ask("blue_player_pilot", "blue_coordinate")
def run_async(): map = [ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 2, 0], [0, 0, 1, 1, 1, 0, 0, 2, 0, 0], [0, 0, 0, 1, 1, 0, 2, 0, 0, 2], [0, 0, 0, 0, 1, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ] walkable = lambda v: v != 2 paths = [ ((0, 0), (8, 8)), ((0, 0), (3, 5)), ((1, 0), (1, 8)), ((0, 0), (8, 8)), ((0, 0), (8, 8)), ((0, 0), (8, 8)), ((0, 0), (8, 8)), ((0, 0), (8, 8)), ((0, 0), (8, 8)), ((0, 0), (8, 8)), ((0, 0), (8, 8)), ((0, 0), (8, 8)), ((0, 0), (8, 8)), ((0, 0), (8, 8)), ] * 100 agent_size = 2 with timewith(): grid = Grid(map) finder = Pathfinder(astar.search, heuristic=cardinal_intercardinal) grid.annotate(walkable) # Compute all the paths serially computed_paths = [] for start, end in paths: computed_paths.append( finder.get_path(start[0], start[1], end[0], end[1], agent_size)) assert len(computed_paths) == len(paths) # Multithreaded version. It should take almost the same as the previous one (or more due to overhead of threads) # since computing the path is a purely CPU bound operation. # Node: The options IS NOT threadsafe class PathFinderLocal(threading.local): def __init__(self): print("Initializing local") local_grid = Grid(map) local_grid.annotate(walkable) self.finder = Pathfinder(astar.search, heuristic=cardinal_intercardinal) local_finder = PathFinderLocal() with timewith(): with ThreadPoolExecutor(max_workers=5) as executor: def _(path_to_do): return local_finder.finder.get_path( path_to_do[0][0], path_to_do[0][1], path_to_do[1][0], path_to_do[1][1], agent_size, ) computed_paths = executor.map(_, paths) assert len(list(computed_paths)) == len(paths)
def __init__(self): print("Initializing local") local_grid = Grid(map) local_grid.annotate(walkable) self.finder = Pathfinder(astar.search, heuristic=cardinal_intercardinal)
class FileManager(cmd.Cmd): def __init__(self): super().__init__() # Из cfg.txt считывается рабочая директория, # за пределы которой выйти будет нельзя with open('cfg.txt') as f: root = f.readline() # Создается объект, преобразующий ввод в полноценные пути # Он получает на вход рут, и вернет код ошибки, если его покинуть self.pathfinder = Pathfinder(root) # Приветствие при запуске intro = 'Welcome to Fima file manager. Type help or ? to list commands.\n' # Приглашение к вводу prompt = '(Fima) ' # Метод, предварительно обрабатывающий ввод def precmd(self, line): # Если ввод - это просьба о помощи, она просто передается дальше if line[:4] == 'help' or line[0] == '?': return line # Если другая команда - из аргументов делаются абсолютные пути # Таким образом проверяется, не пытается ли пользователь # выйти за границы своих возможностей args = line.split(' ') try: args = args[0] + ' ' + ' '.join(map(self.pathfinder.make_path, args[1:])) except EnvironmentError: # Когда pathfinder возвращает код ошибки, пользовательский ввод # превращается в команду, вызывающую сообщение о отсутствии прав доступа return 'oos' else: return args def do_oos(self, arg): 'Punishes you for leaving a root tree' print('Access denied!') def do_pwd(self, arg): 'Print working directory: pwd' print(self.pathfinder.working_directory) def do_lsd(self, arg): 'List of all files and directories in current directory:\n\tlsd' print('\n'.join(list_dir(self.pathfinder.working_directory))) def do_chd(self, destination): 'Change working directory:\n\tchd myDir' print(self.pathfinder.change_wd(destination)) def do_crd(self, name): 'Create a new directory:\n\tcrd myDir' print(create_dir(name)) def do_rmd(self, name): 'Remove a directory:\n\trmd myDir' print(remove_dir(name)) def do_crf(self, name): 'Create a new file:\n\tcrf myFile' print(create_file(name)) def do_rmf(self, name): 'Remove a file:\n\trmf myFile' print(remove_file(name)) def do_wtf(self, arg): 'Write to file:\n\twtf myFile' print(write_to_file(arg)) def do_rdf(self, arg): 'Read a file:\n\trdf myFile' print(read_file(arg)) def do_cpf(self, args): 'Copy a file:\n\tcpf srcFile destFile' print(copy_file(*args.split(' '))) def do_mvf(self, args): 'Move a file:\n\tmvf srcFile destFile' print(move_file(*args.split(' '))) def do_exit(self, arg): 'Exit file manager:\n\texit' print('Thank you for using Fima') return True
import pygame import sys import random from map import Map from visualiser import Visualiser from pathfinder import Pathfinder map = Map() map.loadData() visualiser = Visualiser("Inlupp 2 - Visualiser", map.getWidth(), map.getHeight()) visualiser.setMap(map) pathfinder = Pathfinder(visualiser, map) pathfinder.findCheapestPath() visualiser.runLoop()
from map import Map, load_map from pathfinder import Pathfinder map_40 = load_map() start = 8 goal = 27 pathfinder = Pathfinder(map_40, start, goal) path = pathfinder.path map_40.draw(path)