class Demo( Thread ): """manages an escape machine game """ LEVELS = [ {"r":3, "c":4, "ge":1, "rs":80, "comp":30, "con":60} ] # 5 def __init__( self, gui, assembly_graph, level=0, rank_window=True ): Thread.__init__( self ) self.gui = gui self.assembly_graph = assembly_graph self.level = level self.maze = None # determines color ranking from assembly graph self.color_demon = None if rank_window: self.color_demon = Color_Demon( assembly_graph, self.gui ) self.color_demon.show() else: self.color_demon = Color_Demon( assembly_graph ) self.next_queue = Queue() # start first maze self.next( True, 0, 0 ) def run( self ): while self.next_queue is not None: game_over, escaped, eaten = self.next_queue.get() self._next_maze( game_over, escaped, eaten ) def next( self, game_over, escaped, eaten ): self.next_queue.put( (game_over, escaped, eaten) ) def _next_maze( self, game_over, escaped, eaten ): """build next maze when previous maze is closed """ # if last level wasn't lost go to next level if not game_over: self.level += 1 if self.level > (len(self.LEVELS) - 1): self.level = len(self.LEVELS) - 1 print "***level %d***" % self.level self.maze = Maze( gui=self.gui, next=self.next, rows=self.LEVELS[self.level]["r"], columns=self.LEVELS[self.level]["c"], ghost_eaters=self.LEVELS[self.level]["ge"], room_size=self.LEVELS[self.level]["rs"], completeness=self.LEVELS[self.level]["comp"], connectedness=self.LEVELS[self.level]["con"], escaped=escaped, eaten=eaten ) self.maze.show() self.color_demon.maze = self.maze
def test_robot_move_updates_maze(self): maze = Maze(7) brain = Brain(maze) robot_pos = [1, 4] bat = RoboBat(maze, robot_pos, brain) bat.move_in_direction("left") self.assertFalse(maze.value_at_point(robot_pos) == 3) self.assertTrue(maze.value_at_point(bat.pos) == 3)
def __generate_map(self): _maze = Maze(self.lvl_length, self.lvl_width) self.map = _maze.gen_map() self.lvl_length = _maze.length self.lvl_width = _maze.width # Add a few open spaces _tf = TerrainFactory() for j in range(randrange(1,4)): _row = randrange(4, self.lvl_length - 4) _col = randrange(4, self.lvl_width - 4) for _r in (-1, 0, 1): for _c in (-1, 0 , 1): self.map[_row + _r][_col + _c] = _tf.get_terrain_tile(CYBERSPACE_FLOOR)
def _next_maze( self, game_over, escaped, eaten ): """build next maze when previous maze is closed """ # if last level wasn't lost go to next level if not game_over: self.level += 1 if self.level > (len(self.LEVELS) - 1): self.level = len(self.LEVELS) - 1 print "***level %d***" % self.level self.maze = Maze( gui=self.gui, next=self.next, rows=self.LEVELS[self.level]["r"], columns=self.LEVELS[self.level]["c"], ghost_eaters=self.LEVELS[self.level]["ge"], room_size=self.LEVELS[self.level]["rs"], completeness=self.LEVELS[self.level]["comp"], connectedness=self.LEVELS[self.level]["con"], escaped=escaped, eaten=eaten ) self.maze.show() self.color_demon.maze = self.maze
def __init__(self): self.mode=0#mapping mode ''' Constructor mode=0 er mapping mode=1 er goToPath ''' self.logger=logging.getLogger("robot.Mapping") self.logger.info("Mapping initialised") self.mode=0#mapping self.maze=Maze() self.globalCompass=[0,1,2,3]#north/east/south/west self.startDirection=self.globalCompass[2] self.direction=self.startDirection#south self.startPosition =[0,0] self.currentPosition=self.startPosition#x,y self.lastWas180=False self.lastPosition=self.currentPosition self.funcDict={ 0:self.subY, 1:self.addX, 2:self.addY, 3:self.subX} self.stack=[] '''
def loadMaze(self,jsonfile): with open(jsonfile) as jsondata: data = json.load(jsondata) maze = data["layout"] heading = data["robot_orientation"] start = Point(data["start_pos"]["x"],data["start_pos"]["y"]) location = Point(data["robot_pos"]["x"],data["robot_pos"]["y"]) finish = Point(data["finish_pos"]["x"],data["finish_pos"]["y"]) m = Maze(maze) m.setStart(start) m.setFinish(finish) m.setLocation(location) m.setHeading(heading) return m
def createMaze(): "Original Design" maze = Maze() r1 = Room(1) r2 = Room(2) door = Door(r1, r2) r1.setSide('North', Wall()) r1.setSide('West', Wall()) r1.setSide('South', Wall()) r1.setSide('East', door) r2.setSide('North', Wall()) r2.setSide('West', door) r2.setSide('South', Wall()) r2.setSide('East', Wall()) maze.addRoom(r1) maze.addRoom(r2) return maze
def __init__(self): self._tw_pub = rospy.Publisher(TWIST_PUB, Twist) self._rate = rospy.Rate(RATE) self._checks = { Direction.FORWARD: None,\ Direction.LEFT: None,\ Direction.RIGHT: None,\ "ARRAY": None\ } self._sense_subs = [\ rospy.Subscriber(BUMPER_IO, TurtlebotSensorState, self._collision),\ rospy.Subscriber(SCAN_IO, Float64MultiArray, self._scan)\ ] self.maze = Maze() self._last_collision = None
def __init__(self,gridSize=32,frameRate=60): super(Game,self).__init__('TheGame.You Lost It.') pygame.init() self.framerate = frameRate self.maze = Maze(gridSize) self.maze.read("theMaze") self.screen = pygame.display.set_mode(self.maze.rect.size,0,32) self.clock = pygame.time.Clock() self.paused = False self.add(AttractMode(self)) self.add(SetupLevelMode(self)) self.add(PlayingMode(self)) self.add(IntermissionMode(self)) self.add(GameOverMode(self)) self.setStateByName(PlayingMode.name)
from Maze import Maze from astar_search import astar_search # null heuristic, useful for testing astar search without heuristic (uniform cost search). def null_heuristic(state): return 0 # Test problems # several test on different mazes, some given and some created. Uncomment to run. # 3 different heuristics are also available if __name__ == "__main__": test_maze3 = Maze("maze3.maz") test_mpA = MazeworldProblem(test_maze3, (1, 4, 1, 3, 1, 2)) test_maze4 = Maze("maze4.maz") test_mpB = MazeworldProblem(test_maze4, (8, 8, 8, 9, 8, 10)) test_maze2 = Maze("maze2.maz") test_mpC = MazeworldProblem(test_maze2, (3, 0)) test_maze5 = Maze("maze5.maz") test_mpD = MazeworldProblem(test_maze5, (4, 8, 3, 8, 2, 8)) test_maze6 = Maze("maze6.maz") test_mpE = MazeworldProblem(test_maze6, (6, 4)) test_maze7 = Maze("maze7.maz") test_mpF = MazeworldProblem(test_maze7, (8, 7, 1, 7)) # this should explore a lot of nodes; it's just uniform-cost search result = astar_search(test_mpA, null_heuristic) print(result)
from MazeworldProblem import MazeworldProblem from Maze import Maze from astar_search import bfs_search from astar_search import astar_search # null heuristic, useful for testing astar search without heuristic (uniform cost search). def null_heuristic(state): return 0 # Test problems test_maze1 = Maze("maze1.maz") print(test_maze1) test_mp = MazeworldProblem(test_maze1, (32, 4)) # this should explore a lot of nodes; it's just uniform-cost search result = astar_search(test_mp, null_heuristic) print(result) # this should do a bit better: result = astar_search(test_mp, test_mp.manhattan_heuristic) print(result) # test_mp.animate_path(result.path) result = astar_search(test_mp, test_mp.bfs_heuristic) print(result)
class Strategy_HuntAndKill(IMazeGenerator): def __init__(self, width, height): self.__maze = Maze(width, height) def generate(self): current_cell = self.__maze.getRandomOrigin() self.__maze.markVisitedCell(current_cell) have_more_cells_to_hunt = True while have_more_cells_to_hunt: while self.__maze.hasUnvisitedNeightbours(current_cell) == True: unvisited_cell = self.__maze.getRandomUnvisitedNeightbour(current_cell) self.__maze.removeWallBettweCells(current_cell, unvisited_cell) current_cell = unvisited_cell self.__maze.markVisitedCell(current_cell) current_cell = self.huntForAvailableCell() if current_cell is None: have_more_cells_to_hunt = False self.__maze.addEntryAndExitPoints() def huntForAvailableCell(self): for cell in self.__maze.cells(): if self.__maze.hasUnvisitedNeightbours(cell): print (cell.getX(), cell.getY()) return cell return None def getRaw(self): return self.__maze.getRaw() def getJSON(self): return self.__maze.getJSON() def __str__(self): return 'Strategy_HuntAndKill'
#APPLICATION: print( "Bienvenue! \nVous allez devoir atteindre la sortie du labyrinthe! Votre personnage est symbolisé par (X) et la sortie par (O).\nVous devez ramasser les trois objets pour endormir le garde et vous enfuir.\nVous pouvez quitter le jeu a tout moment en tappant q." ) while UserName == "": #loop of name demand, if nothing is written it asks name again UserName = User.GetName() User.Greetings(UserName) print( "\nPour vous déplacer utilisez les touches: \n(u) pour aller en haut, (d) pour aller en bas, (l) pour aller à gauche et (r) pour aller à droite.\n" ) #Loading of the maze from text file: Maze.LoadFromTextFile(MazeMap) #Display objects inside the maze: Object.PutObjectsInMaze(MazeMap, ObjectsList) #Maze display: Maze.DrawOnScreen(MazeMap) while ContinueGame == True: #Game loop, while the user don't get out, don't win or loose it asks him/her to enter commands and it redraw the maze on screen. ContinueGame = Game.GetAndExecuteCommands(MazeMap, UserName) Maze.DrawOnScreen(MazeMap) os.system("pause")
def __init__(self): self._maze = Maze() self._player = Player(self._maze) pass
def __init__(self,maze): self.maze = Maze(maze) self.current_position = self.maze.current_position self.visited_positions = {self.current_position} self.path_queue = deque()
class BFSSolver: def __init__(self,maze): self.maze = Maze(maze) self.current_position = self.maze.current_position self.visited_positions = {self.current_position} self.path_queue = deque() def solve(self): x,y = self.current_position self.visited_positions.add((x,y)) path = [self.current_position] while not self.maze.is_end(x,y): self.maze.mark_checked(x,y) if (x,y+1) not in self.visited_positions and self.maze.is_open(x,y+1): self.visited_positions.add((x, y + 1)) new_path = list(path) new_path.append((x, y + 1)) self.path_queue.append(new_path) if (x,y-1) not in self.visited_positions and self.maze.is_open(x,y-1): self.visited_positions.add((x, y - 1)) new_path = list(path) new_path.append((x, y - 1)) self.path_queue.append(new_path) if (x+1,y) not in self.visited_positions and self.maze.is_open(x+1,y): self.visited_positions.add((x + 1, y)) new_path = list(path) new_path.append((x + 1, y)) self.path_queue.append(new_path) if (x-1,y) not in self.visited_positions and self.maze.is_open(x-1,y): self.visited_positions.add((x - 1, y)) new_path = list(path) new_path.append((x - 1, y)) self.path_queue.append(new_path) path = self.path_queue.popleft() x,y = path[len(path)-1] prevX, prevY = self.current_position for (solX, solY) in path: if solY > prevY: if not self.maze.move('s'): logging.error("Failed move south") if solY < prevY: if not self.maze.move('n'): logging.error("Failed move north") if solX > prevX: if not self.maze.move('e'): logging.error("Failed move east") if solX < prevX: if not self.maze.move('w'): logging.error("Failed move west") prevX = solX prevY = solY if self.maze.at_end(): logging.info("Solved in " + str(len(path)) + " moves!") self.maze.print_solution() else: logging.error("Failed! End position: " + str(self.maze.END_POSITION) + " Current position: " + str(self.maze.current_position))
moves = 0 turns = 0 running = True display = pygame.display.set_mode((700,700)) myfont = pygame.font.SysFont("monospace", 30) # render text title = myfont.render("Run-In-A-Maze Game!", 15, (255,255,0)) display.blit(title, (10, 10)) # SURFACES ARE PASSED BY REFERENCE current = Maze(display, 18, 20) current.mazify() #current.place(display, random.randint(0, current.getrow()), random.randint(0, current.getcol())) current.draw(40, 60) while running: display.blit(myfont.render("Turns: " + str(turns), 15, (255, 255, 0)), (10, 30)) pygame.display.update() pygame.time.delay(10) for event in pygame.event.get(): if event.type == pygame.QUIT: running = False if event.type == pygame.KEYDOWN:
def GenerateMaze(self, width, height): theMaze = Maze() theMaze.SetDimensions(width, height) # treat the maze generation as a depth first search # start with the top corner as the first cell maze_cells = [] adjacent_cells = {} # choose a start cell current_cell = [np.random.randint(0, theMaze.height), np.random.randint(0, theMaze.width)] maze_cells.append("%d-%d" % (current_cell[0], current_cell[1])) # create adjacency list borders = theMaze.GetBorders(current_cell) for index in xrange(len(borders)): if borders[index] == 0: new_cell = deepcopy(current_cell) if index == 0: new_cell[0] -= 1 elif index == 1: new_cell[1] += 1 elif index == 2: new_cell[0] += 1 elif index == 3: new_cell[1] -= 1 cell_key = "%d-%d" % (new_cell[0], new_cell[1]) adjacent_cells[cell_key] = [] adjacent_cells[cell_key].append([current_cell, index]) # print "FIRST SET", adjacent_cells, maze_cells while len(adjacent_cells) > 0: # choose a cell to add to the maze at random cell_key = np.random.randint(0, len(adjacent_cells)) cell_key = adjacent_cells.keys()[cell_key] cell = adjacent_cells[cell_key] del (adjacent_cells[cell_key]) maze_cells.append(cell_key) cell_key = map(int, cell_key.split("-")) if self.mVerbosity > 0: print "active cell: ", cell_key, "|", cell, len(cell) # choose a random edge from the set of edges connecting me connectedCell = np.random.randint(0, len(cell)) connectedCell = cell[connectedCell] wallToOpen = connectedCell[1] rWallToOpen = (wallToOpen + 2) % 4 connectedCell = connectedCell[0] if self.mVerbosity > 0: print " connect to", connectedCell, "by", wallToOpen, "-", rWallToOpen theMaze.cells[connectedCell[0], connectedCell[1], wallToOpen] = 1 theMaze.cells[cell_key[0], cell_key[1], rWallToOpen] = 1 borders = theMaze.GetBorders(cell_key) for index in xrange(len(borders)): if borders[index] == 0: new_cell = deepcopy(cell_key) if index == 0: new_cell[0] -= 1 elif index == 1: new_cell[1] += 1 elif index == 2: new_cell[0] += 1 elif index == 3: new_cell[1] -= 1 new_cell_key = "%d-%d" % (new_cell[0], new_cell[1]) if new_cell_key not in maze_cells: if new_cell_key not in adjacent_cells: adjacent_cells[new_cell_key] = [] adjacent_cells[new_cell_key].append([cell_key, index]) theMaze.end_cell = [0, 0] theMaze.start_cell = [theMaze.height - 1, theMaze.width - 1] return theMaze
def GenerateMaze(self, width, height): theMaze = Maze() theMaze.SetDimensions(width, height) # treat the maze generation as a depth first search # start with the top corner as the first cell active_cells = [] dead_cells = [] active_cells.append([0, 0]) while len(active_cells) > 0: thisCell = active_cells[-1] if self.mVerbosity > 0: print "active cell", thisCell, # remove a wall from this cell exits = theMaze.GetBorders(thisCell) # choose a random exit to open walls = exits == 0 wallToOpen = None choices = list(np.arange(4)[walls]) if self.mVerbosity > 0: print "walls", choices while wallToOpen is None and len(choices) > 0: wallIndex = np.random.randint(len(choices)) wallToOpen = choices[wallIndex] choices.pop(wallIndex) newCell = deepcopy(thisCell) # wallToOpen = np.random.choice(choices) # choices.remove(wallToOpen) if wallToOpen == 0: newCell[0] -= 1 elif wallToOpen == 1: newCell[1] += 1 elif wallToOpen == 2: newCell[0] += 1 else: newCell[1] -= 1 if self.mVerbosity > 0: print " choose: ", wallToOpen, newCell, (wallToOpen + 2) % 4 if newCell in active_cells or newCell in dead_cells: if self.mVerbosity > 0: print " Bad choice", "Active" if newCell in active_cells else "Dead" wallToOpen = None # if choice is none, we ran out of options if wallToOpen is None: active_cells.pop(-1) dead_cells.append(thisCell) else: # alright! neighbbor! rWallToOpen = (wallToOpen + 2) % 4 # print " open %d and %d" % (wallToOpen, rWallToOpen) theMaze.cells[thisCell[0], thisCell[1], wallToOpen] = 1 theMaze.cells[newCell[0], newCell[1], rWallToOpen] = 1 active_cells.append(newCell) # if np.count_nonzero(exits > 0) >= 2: # active_cells.pop(-1) # dead_cells.append(thisCell) # theMaze.end_cell = [0, 0] # theMaze.start_cell = [theMaze.height -1, theMaze.width -1] if self.mVerbosity > 0: print return theMaze
class Mapping(): ''' classdocs ''' stepsPrCell=6000 def __init__(self): self.mode=0#mapping mode ''' Constructor mode=0 er mapping mode=1 er goToPath ''' self.logger=logging.getLogger("robot.Mapping") self.logger.info("Mapping initialised") self.mode=0#mapping self.maze=Maze() self.globalCompass=[0,1,2,3]#north/east/south/west self.startDirection=self.globalCompass[2] self.direction=self.startDirection#south self.startPosition =[0,0] self.currentPosition=self.startPosition#x,y self.lastWas180=False self.lastPosition=self.currentPosition self.funcDict={ 0:self.subY, 1:self.addX, 2:self.addY, 3:self.subX} self.stack=[] ''' 1 : self.goStraight, 2 : self.turnRight, 3 : self.turn180, 4 : self.turnLeft } table: 0,0 -------------- x,0 | | | | | | 0,y ''' def receiveStack(self,path): self.mode=1#path finding go to mode self.stack=path#self.pathToStack() print self.stack def getLocalDirection(self,lastS,s): #print lastS left=lastS-1 if left<0: left=3 right=lastS+1 if right>3: right=0 direction180=lastS-2 if direction180 < 0: direction180+=4 if left==s: return 2 elif right==s: return 4 elif direction180==s: return 3 return 1 def getCurrentPosition(self): print "mapping getCurrentPosition" print"currentPos="+str(self.currentPosition) return self.currentPosition def stepsToCells(self,steps): #print steps cells=(steps*1.0)/(self.stepsPrCell*1.0) decimals=cells % 1 cells=int(cells) if decimals > 0.68 and cells<1: cells+=1 elif decimals > 0.68: cells+=1 self.logger.info("cells/"+str(cells)) return cells def wallsToGlobalWalls(self,walls): north=0 east=0 south=0 west=0 if(self.startPosition == self.currentPosition):#south north=1 east=walls[0] south=walls[2] west=walls[1] else: if(self.direction==0):#north west=walls[0] east=walls[1] south=0 north=walls[2] elif(self.direction==1):#east west=0 east=walls[2] south=walls[1] north=walls[0] elif(self.direction==2):#south north=0 east=walls[0] south=walls[2] west=walls[1] else:#west west=walls[2] east=0 south=walls[0] north=walls[1] return [north,east,south,west] def wallsToInt(self,walls): value=(((walls[0]<<3) | (walls[1]<<2)) | (walls[2]<<1)) | (walls[3]) return value def getChoice(self,steps=None,walls=None): if not self.mode: return self.mappingChoice(steps, walls) else: return self.gotoChoice() def gotoChoice(self): returnChoice=[0,0]#steps,local direction cells=0 if self.stack: choice=self.stack.pop() cells=choice[1] returnChoice[0]=cells*self.stepsPrCell calcChoice=self.makeChoice([choice[0]]) returnChoice[1]=calcChoice[3] self.direction=calcChoice[1] self.currentPosition=[choice[2],choice[3]] print( "dir="+str(self.direction) +"\tpoos"+str(self.currentPosition) +"\tchoice"+str(returnChoice) ) return returnChoice def mappingChoice(self,steps,walls): self.logger.info("directionIn/"+str(self.direction)) func=self.funcDict[self.direction] tmpWalls=self.wallsToGlobalWalls([1,1,0]) cells=self.stepsToCells(steps)+1 print "cells="+str(cells) for i in range(cells): tmpWalls=self.wallsToInt(self.wallsToGlobalWalls([1,1,0])) tmp=self.maze.get(self.currentPosition[0], self.currentPosition[1]) if not tmp: self.maze.set(self.currentPosition[0], self.currentPosition[1], tmpWalls) self.currentPosition=func(self.currentPosition) tmp=self.maze.get(self.currentPosition[0], self.currentPosition[1]) globalWalls=self.wallsToGlobalWalls(walls) if not tmp: self.maze.set(self.currentPosition[0], self.currentPosition[1], self.wallsToInt(globalWalls)) #self.currentPosition=self.funcDict[self.direction](self.currentPosition) print "after incrementation current pos="+str(self.currentPosition)+" dir="+str(self.direction) missingWalls=self.findMissingWalls(self.currentPosition,globalWalls) unexploredCells=self.findUnexploredCells(self.currentPosition,missingWalls) returnChoice=0 if len(missingWalls)==1:#180 if self.stack:#still unexplored nodes self.logger.info("180") self.stack.pop() self.logger.info("stack/"+str(self.stack)) choice=self.makeChoice(missingWalls) returnChoice=3 self.direction=choice[1] else: pass else: if unexploredCells: self.logger.info("exploring") choice=[self.makeChoice(unexploredCells),self.currentPosition] self.stack.append(choice) self.logger.info("stack/"+str(self.stack)) returnChoice=choice[0][3] self.direction=choice[0][1] elif self.stack: self.logger.info("backtracking") choice=self.stack.pop() choice=self.makeChoice([choice[0][0]]) self.currentPosition=choice[1] self.logger.info("stack/"+str(self.stack)) returnChoice=choice[0][3] self.direction=choice[0][1] else: print "finnished mapping" #func=self.funcDict[self.direction] #self.currentPosition=func(self.currentPosition) return 0 print( "dir="+str(self.direction) +"\tpos"+str(self.currentPosition) +"\tchoice"+str(returnChoice) ) self.logger.info("returnChoice/"+str(returnChoice)) self.logger.info("currentpos/"+str(self.currentPosition)) self.logger.info("directionOut/"+str(self.direction)) self.lastPosition=self.currentPosition return returnChoice def findMissingWalls(self,pos,globalWalls): posibilities=[] for d in range(4): if not globalWalls[d]: posibilities.append(d) return posibilities def findUnexploredCells(self,pos,missingWalls): posibilities=[] for d in missingWalls: xy=self.funcDict[d](pos) if xy[0]>=0 and xy[1]>=0: tmp=self.maze.get(xy[0], xy[1]) if not tmp: posibilities.append(d) return posibilities def makeChoice(self,posibilities): left=self.direction-1 if left<0: left=3 right=self.direction+1 if right>3: right=0 back=self.direction-2 if back < 0: back+=4 #print "direction="+str(self.direction)+"back before="+str(back)+" back after"+str(back2) if self.direction in posibilities: return [back,self.direction,1,1] # som i [til brug, til stack, til turnthread] elif right in posibilities: return [left,right,2,4] elif left in posibilities: return [right,left,4,2] lol=[self.direction,back,1,3] #self.stack.append(lol) #self.stack.append(lol) return lol def addX(self,xy): return [xy[0]+1,xy[1]] def subX(self,xy): return [xy[0]-1,xy[1]] def addY(self,xy): return [xy[0],xy[1]+1] def subY(self,xy): return [xy[0],xy[1]-1] def getMaze(self): return self.maze
print("") node1 = Node(False, False, False, False, (0, 0), False) node2 = Node(False, False, False, False, (0, 1), False) node3 = Node(False, False, False, False, (1, 1), False) node4 = Node(False, False, False, False, (-1, 1), False) node1.set_up(node2) node2.set_down(node1) node2.set_left(node4) node2.set_right(node3) node3.set_left(node2) node4.set_right(node2) nodes = [node1, node2, node3, node4] foo = Maze(nodes) agent1 = Agent(node1, foo) agent2 = Agent(node4, foo) agents = [agent1, agent2] print("Begin maze") print("Agent 1 location: ", agent1.current_pos) print("Agent 2 location: ", agent2.current_pos) while (len(agent1.maze.undiscovered) > 0): input(">>> Press enter to continue") PPSOCycle(agents) PrintAgent(agents[0], 1) PrintAgent(agents[1], 2) print("Maze fully Discovered!")
class DFSSolver: def __init__(self, maze): self.maze = Maze(maze) self.current_position = self.maze.current_position self.visited_positions = {self.current_position} self.position_stack = [self.current_position] def solve(self): x, y = self.current_position while not self.maze.is_end(x, y): self.maze.mark_checked(x, y) self.visited_positions.add((x, y)) if (x, y + 1) not in self.visited_positions and self.maze.is_open(x, y + 1): self.position_stack.append((x, y + 1)) y += 1 elif (x, y - 1) not in self.visited_positions and self.maze.is_open(x, y - 1): self.position_stack.append((x, y - 1)) y -= 1 elif (x + 1, y) not in self.visited_positions and self.maze.is_open(x + 1, y): self.position_stack.append((x + 1, y)) x += 1 elif (x - 1, y) not in self.visited_positions and self.maze.is_open(x - 1, y): self.position_stack.append((x - 1, y)) x -= 1 else: prevX, prevY = self.position_stack.pop() x, y = self.position_stack[len(self.position_stack) - 1] prevX, prevY = self.current_position for (solX, solY) in self.position_stack: if solY > prevY: if not self.maze.move("s"): logging.error("Failed move south") if solY < prevY: if not self.maze.move("n"): logging.error("Failed move north") if solX > prevX: if not self.maze.move("e"): logging.error("Failed move east") if solX < prevX: if not self.maze.move("w"): logging.error("Failed move west") prevX = solX prevY = solY if self.maze.at_end(): logging.info("Solved in " + str(len(self.position_stack)) + " moves!") self.maze.print_solution() else: logging.error( "Failed! End position: " + str(self.maze.END_POSITION) + " Current position: " + str(self.maze.current_position) )
def setUp(self): self.m = Maze()
def __init__(self, maze): self.maze = Maze(maze) self.current_position = self.maze.current_position self.visited_positions = {self.current_position} self.position_stack = [self.current_position]
y.add(state[2]) return len(x) + len(y) def __str__(self): string = "Blind robot problem: " return string # given a sequence of states (including robot turn), modify the maze and print it out. # (Be careful, this does modify the maze!) def animate_path(self, path): # reset the robot locations in the maze self.maze.robotloc = tuple(self.start_state) for state in path: print(str(self)) self.maze.robotloc = tuple(state) sleep(1) print(str(self.maze)) ## A bit of test code if __name__ == "__main__": test_maze3 = Maze("maze3.maz") test_problem = SensorlessProblem(test_maze3) print(test_problem.start_state) for successor_belief_state in test_problem.get_successors( test_problem.start_state): print(successor_belief_state)
from l33tC4D.gui.Gui import Gui from Maze import Maze from time import sleep gui = Gui() gui.start() maze = Maze(gui, rows=4, columns=7, ghost_eaters=3, room_size=80, completeness=0, connectedness=50) maze.show() sleep(1.0) maze.rank_colors({0: [2, 1, 3], 1: [2, 0], 2: [1, 0], 3: [0]})
import turtle from time import sleep from Maze import Maze window = turtle.Screen() mazePen = turtle.Turtle() mazePen.speed(0) maze = Maze(15) maze.loadMaze('maze.txt') delay = turtle.delay() tracer = turtle.tracer() turtle.tracer(0, 0) maze.drawMaze(mazePen) turtle.update() turtle.tracer(tracer, delay) sleep(5) solPen = turtle.Turtle() solPen.color('red', 'green') maze.solveMaze(solPen) window.exitonclick()
class Move_Manager(object): def __init__(self): self._tw_pub = rospy.Publisher(TWIST_PUB, Twist) self._rate = rospy.Rate(RATE) self._checks = { Direction.FORWARD: None,\ Direction.LEFT: None,\ Direction.RIGHT: None,\ "ARRAY": None\ } self._sense_subs = [\ rospy.Subscriber(BUMPER_IO, TurtlebotSensorState, self._collision),\ rospy.Subscriber(SCAN_IO, Float64MultiArray, self._scan)\ ] self.maze = Maze() self._last_collision = None def debug(self, a=1): print(self._checks["ARRAY"]) # 1: right # 2: left # 3: both # just record that we hit something def _collision(self, data): # TODO return collisions = data.bumps_wheeldrops if collisions == 0 or self._last_collision is not None: return self.stop() self._send_twist(-COLLISION_X, 0) self._last_collision = collisions # executed when we have the chance def _handle_collision(self): self.maze.collision() self._last_collision = None # LaserScan callback def _scan(self, data): arr = data.data self._checks[Direction.RIGHT] = arr[0] self._checks[Direction.FORWARD] = arr[1] self._checks[Direction.LEFT] = arr[2] self._checks["ARRAY"] = arr # TODO: buggy # try to adjust the left and right side to be equidistant from an imaginary wall def center(self, count=1): if self._checks["ARRAY"] is None or \ self._checks[Direction.FORWARD] > MIN_DIST or \ count > CENTER_MAX_COUNT or\ not DO_CENTER: return num = count + 1 diff = self._checks[Direction.LEFT] - self._checks[Direction.RIGHT] # avoid adjustements that are too big (possibly just bad detection) # avoid minute adjustements if abs(diff) > CENTER_MAX_COUNT * CENTER_INC or \ abs(diff) < CENTER_TURN_DIST: return # HACK # guessing here, but we need to make a better decision here # should the robot turn towards or away from a wall? coeff = 1 if abs(diff) > CENTER_MAX_COUNT * CENTER_INC / 2: coeff = -1 self._send_twist(CENTER_FORWARD, 0) self._send_twist(0, coeff * CENTER_INC) self.center(count=num) # TODO # we don't want to be too close to a wall, we want to be in the center of a "cell" def not_too_close(self, count=1): if self._checks[Direction.FORWARD] < TOO_CLOSE and \ count < CLOSE_MAX_COUNT and \ DO_NOT_GET_CLOSE: self._send_twist(-BACKWARDS_X(CLOSE_INC), 0) c = count + 1 self.not_too_close(count=c) # turning is left to the callee! # if True, then the robot has enough room to perform the directional movement def check(self, direction, num=1): if direction == Direction.FORWARD: self.center() # check that we have room if self._checks[Direction.FORWARD] > MIN_DIST: # ok but are the sides confident? if not DO_GET_EDGE or self._checks[direction] > MIN_DIST: rospy.loginfo(self._checks) return True else: ## need to correct, ## lets nudge forward since we might be looking at a corner # if we are trying to go forward then this check is irrelevant if direction == Direction.FORWARD: rospy.loginfo(self._checks) return False # when middle says we are good # but the sides have something in front! elif direction == Direction.LEFT: if self._checks[direction] < MIN_DIST: self.move(Direction.RIGHT) self.move(Direction.FORWARD, scale=CHECK_SCALE) self.move(Direction.LEFT) else: self.move(Direction.LEFT) self.move(Direction.FORWARD, scale=CHECK_SCALE) self.move(Direction.RIGHT) return self.check(direction) # ^^ elif direction == Direction.RIGHT: if self._checks[direction] < MIN_DIST: self.move(Direction.LEFT) self.move(Direction.FORWARD, scale=CHECK_SCALE) self.move(Direction.RIGHT) else: self.move(Direction.RIGHT) self.move(Direction.FORWARD, scale=CHECK_SCALE) self.move(Direction.LEFT) return self.check(direction) rospy.loginfo(self._checks) return True else: rospy.loginfo(self._checks) return False # we always turn orthogonally so we won't ask for z input def move(self, direction, scale=1): if self._last_collision is not None: self._handle_collision() if direction == Turn.CLOCKWISE: direction = Direction.RIGHT if direction == Turn.COUNTER: direction = Direction.LEFT # NOTE this should be the only place where we delay after movement if direction == Direction.FORWARD: self._send_twist(TWIST_X/scale, 0) self.maze.step() self.center() self.not_too_close() elif direction == Direction.BACKWARD: # NOTE: backward is not just -TWIST_X self._send_twist(-BACKWARD(MAX_DIST)/scale, 0) elif direction == Direction.RIGHT or direction == Direction.LEFT: self._turn(direction) self.maze.turn(direction) self.center() else: rospy.loginfo("invalid direction to move() " + str(direction)) # halt movement of the turtlebot immediately def stop(self): twist = Twist() self._tw_pub.publish(twist) def _turn(self, direction): # an orthogonal turn on a flat surface # HACK right turns suck val = -(TWIST_Z*RIGHT_SCALE) if direction == Direction.RIGHT else (LEFT_SCALE) * TWIST_Z self._send_twist(0, val) # actually send message # similar to what is found in turtlebot min_max tutorial def _send_twist(self, x, z): for _ in range(TWIST_NUM): twist = Twist() twist.linear.x = x twist.angular.z = z self._tw_pub.publish(twist) self._rate.sleep() self.stop() rospy.sleep(DELAY)
from PIL import Image import StringIO import random import base64 import cgi import cgitb cgitb.enable() form = cgi.FieldStorage() rows = 55 cols = 110 iterations = 50 m = Maze(rows, cols) pattern = form['initial'].value if pattern == 'rand': for i in range(0, rows): for j in range(0, cols): m.set_cells(i, j, random.random() <= 0.5) elif pattern == 'line1': for i in range(0, rows): m.set_cells(i, cols/2, True) elif pattern == 'line2': for i in range(0, cols): m.set_cells(rows/2, i, True) for i in range(0, iterations): m.simulate()
# set up assembly graph sensor_queue = Queue() event_queue = Queue() sensor_demon = Sensor_Demon( sensor_queue, serial_port="/dev/ttyUSB0" ) assembly_demon = Assembly_Demon( sensor_queue, event_queue ) assembly_graph = Assembly_Graph( event_queue=event_queue, part_library=part_library, orient=True ) # start demon threads sensor_demon.start() assembly_demon.start() assembly_graph.start() # start gtk gui gui = Gui() gui.start() # build maze maze = Maze( gui, rows=3, columns=6, ghost_eaters=2, room_size=80, completeness=20, connectedness=80 ) maze.show() # assign color demon to update color ranking on assembly graph event color_demon = Color_Demon( assembly_graph, gui ) color_demon.show() color_demon.maze = maze
self.memory.add(state, self.valid_action.index(action), reward, next_state, is_terminal) """间隔一段时间更新target network权重""" if self.step % self.EveryUpdate == 0: for _ in range(2): self._learn(batch=32) """update the step and epsilon""" self.step += 1 self.epsilon = max(0.01, self.epsilon * 0.995) return action, reward def test_update(self): state = self.sense_state() state = np.array(state, dtype=np.int32) state = np.expand_dims(state, axis=0) q_value = self.eval_model.predict(state) action_index = np.argmin(q_value, axis=1).item() action = self.valid_action[action_index] reward = self.maze.move_robot(action) return action, reward if __name__ == "__main__": maze_ = Maze(maze_size=5) robot = MinDQNRobot(maze=maze_)
def test_hardcoded_creation(self): robot_pos = [1, 4] maze = Maze(7) brain = Brain(maze) bat = RoboBat(maze, robot_pos, brain) self.assertEqual(3, maze.value_at_point(robot_pos))
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Fri Oct 5 14:12:30 2018 @author: htaiwan """ from Maze import Maze from Robot import Robot from Runner import Runner epoch = 20 epsilon0 = 0.7 alpha = 0.5 gamma = 0.9 maze_size = (6,6) trap_number = 1 maze = Maze(maze_size=maze_size, trap_number=trap_number) robot = Robot(maze, alpha=alpha, epsilon0=epsilon0, gamma=gamma) robot.set_status(learning=True) runner = Runner(robot, maze) runner.run_training(epoch, display_direction=True) #runner.generate_movie(filename = "final.avi") # 你可以注释该行代码,加快运行速度,不过你就无法观察到视频了。 runner.plot_results()
class Strategy_RecursiveBacktracker(IMazeGenerator): def __init__(self, width, height): self.__maze = Maze(width, height) def generate(self): cell_stack = list() current_cell = self.__maze.getRandomOrigin() self.__maze.markVisitedCell(current_cell) while self.__maze.hasUnvisitedCells() == True: if self.__maze.hasUnvisitedNeightbours(current_cell) == True: unvisited_cell = self.__maze.getRandomUnvisitedNeightbour(current_cell) cell_stack.append(current_cell) self.__maze.removeWallBettweCells(current_cell, unvisited_cell) current_cell = unvisited_cell self.__maze.markVisitedCell(current_cell) elif len(cell_stack) > 0: current_cell = cell_stack.pop() else: current_cell = self.__maze.getRandomUnvisitedCellr() self.__maze.markVisitedCell(current_cell) self.__maze.addEntryAndExitPoints() def getRaw(self): return self.__maze.getRaw() def getJSON(self): return self.__maze.getJSON() def __str__(self): return 'Strategy_RecursiveBacktracker'
from Maze import Maze from Ant import Ant from Bug import Bug import numpy as np from Viewer import draw import cv2 if __name__ == '__main__': np.random.seed(60 ) maze = Maze(10, 10) maze.reset() for _ in range(50): ant = Ant(np.random.randint(10), np.random.randint(10)) maze.add(ant) for _ in range(5): bug = Bug(np.random.randint(10), np.random.randint(10)) maze.add(bug) for step in range(100): print('step: ', step) all_agents = maze.get_all_agents() for agent in all_agents: obs = agent.get_obs(maze) action = agent.step(maze, obs) print(maze) all_agents = maze.get_all_agents() print('%d ants, %d bugs' % (sum([agent.__class__.__name__ == 'Ant' for agent in all_agents]), sum([agent.__class__.__name__ == 'Bug' for agent in all_agents]))) img = draw(maze)
x = x + path[i - 1][0] y = y + path[i - 1][1] if not maze.is_floor(x, y): x = x - path[i - 1][0] y = y - path[i - 1][1] p.append((x, y)) return p ############################################################################# # I recommend ignoring everything up there. They are just helper functions to make live easier. goal = (2, 0) test_maze = Maze("maze4.maz") print(test_maze) test_mp = SensorlessProblem(test_maze, goal) result = astar_search(test_mp, test_mp.num_heuristic) result.path = get_path(result) print(result) test_all(test_maze, test_mp, result.path, goal) #test_mp.animate_path(create_path(test_maze, (2, 0), result.path)) result = astar_search(test_mp, test_mp.spam_heuristic) result.path = get_path(result) print(result) test_all(test_maze, test_mp, result.path, goal) goal = (0, 4) test_maze = Maze("maze3.maz")
successors_list.append( frozenset(successor_belief_set )) # add the generated successors to the list return successors_list def animate_path(self, path): # reset the robot locations in the maze self.maze.robotloc = tuple(self.start_state) print(self.maze.robotloc) for state in path: print(str(self)) temp = [i for tup in state for i in tup] self.maze.robotloc = tuple(temp) sleep(1) print(str(self.maze)) ## A bit of test code if __name__ == "__main__": test_maze1 = Maze("maze1.maz") test_problem = SensorlessProblem(test_maze1) # testing my methods intial = test_problem.generate_intial() test_problem.get_successors(frozenset({(3, 1), (1, 1), (2, 2)})) # just some test code
class Game: """ Game representation New turn with every player move Attributes: map: Maze object which is based on np.array hero: Hero object; player hero_map: Maze object; copy of a game map with hero and trolls marked trolls: list of Troll objects top_layer_on: boolean; Tell if there is a message on the screen top_layer_map: Text_map object; it is for writing a message in the middle of the screen turn: int; actual turn winning_turn: int; turn upon winning status: 0,1,2,3 - pre_start, in_progress, win, lost tkinter variables: root view label """ directions = {'up': 3, 'down': 4, 'left': 5, 'right': 6} grid_elements = {i: j for i, j in enumerate([' ', '#', 'X', '^', 'v', '<', '>', 't'])} def __init__(self, map_width, map_height, restarted=False): self.map = Maze(map_width, map_height) self.map.fill_borders() self.map.make_aisles() self.map.set_exit() self.hero_map = self.map.copy() self.hero = Hero() self.hero.appear(self) self.hero_map.add_obj(3, self.hero.coor[0], self.hero.coor[1]) self.trolls = [] self.top_layer_on = False self.top_layer_map = Text_map() self.turn = 0 self.winning_turn = -1 self.status = 0 self.spawn_trolls(15) self.refresh_hero_map() if not restarted: self.root = tk.Tk() self.view = tk.StringVar() self.label = tk.Label(self.root, font=("Lucida Console", 14), textvariable=self.view) # takefocus=1 may be useful def __str__(self): """ Main "graphics" engine as the game is built without real graphics - just text Interprets nparrays from Maze objects (base labirynth is made with integers 0,1,2), Text_Map and final array are made of string signs """ def decode(str_number): # function to map arrays try: return Game.grid_elements[int(float(str_number))] except KeyError: return str(str_number)[0] # if not found in Game.grid_elements except ValueError: return str_number # top layer signs ' ' etc res = '' res_array = np.empty(self.map.shape, dtype='<U11') res_array[:, :] = self.hero_map.grid # Checking if needed and calculating top_layer with message for player if self.top_layer_on: top_layer_x_start = (self.map.shape[1] - self.top_layer_map.shape[1]) // 2 top_layer_y_start = (self.map.shape[0] - self.top_layer_map.shape[0]) // 2 res_array[top_layer_y_start : top_layer_y_start + self.top_layer_map.shape[0], top_layer_x_start: top_layer_x_start + self.top_layer_map.shape[1]] = self.top_layer_map.grid # 'printing' results for i in range(self.map.shape[0]): str_array_line = np.array(list(map(decode, res_array[i, :]))) res += ''.join(str_array_line) res += '\n' return res def play(self): """ Main game function. Captures key presses, launches tk.root.mainloop() to start the app """ self.status = 1 a = str(self) self.view.set(a) self.root.bind('<Up>', self.hero_up) self.root.bind('<Down>', self.hero_down) self.root.bind('<Left>', self.hero_left) self.root.bind('<Right>', self.hero_right) self.root.bind('<r>', self.restart) self.label.pack() self.root.mainloop() def hero_up(self, key_pressed): self.hero_action('up') self.new_turn() def hero_down(self, key_pressed): self.hero_action('down') self.new_turn() def hero_left(self, key_pressed): self.hero_action('left') self.new_turn() def hero_right(self, key_pressed): self.hero_action('right') self.new_turn() def restart(self, key_pressed): """ Restarts the game """ if self.status > 1: shape = self.map.shape self.__init__(self.map.shape[1], self.map.shape[0], restarted=True) self.play() def new_turn(self): """ Controls every new turn calculates trolls moves, refreshes map, checks if game is lost Sets new viewport """ self.trolls_action() self.refresh_hero_map() self.turn += 1 if self.is_lost(): self.lose() self.view.set(str(self)) def hero_action(self, direction): """ Controls hero move after given key press Checks if hero should turn himself or go in given direction if he's already turned there Win/Lose is also checked at the end """ if self.status == 3: pass elif not self.hero.turn(direction): if self.check_space(self.hero.coor, direction) == 0: if self.hero.move(direction): return True elif self.check_space(self.hero.coor, direction) == 1: if self.check_wall(direction) == 0: self.push_wall(direction) self.hero.move(direction) elif self.check_space(self.hero.coor, direction) == 2: self.win() elif self.check_space(self.hero.coor, direction) == 7: # 7 means trolls self.lose() def spawn_trolls(self, n): """ Iterates through self.trolls list and spawns them. n: number of trolls """ for i in range(n): self.trolls.append(Troll(self)) self.trolls[i].appear(self) def trolls_action(self): """ Iterates through self.trolls list and controlls them. Every troll finds his path to hero and moves towards him. """ for troll in self.trolls: troll.copy_game_map() troll.find_path() direction = troll.path[1]['direction'] if not troll.turn(direction): troll.move(direction) def clear_trolls(self): """ Deletes all trolls from the game. """ self.trolls.clear() def check_space(self, coor, direction, length=1): """ Checks space in given direction from the given coordinates length: int; tells how far we are checking returns value of a grid: int: 0-7""" assert direction in list(Game.directions.keys()) try: if direction == 'up': return self.hero_map.grid[coor[0]-length, coor[1]] elif direction == 'down': return self.hero_map.grid[(coor[0]+length, coor[1])] elif direction == 'left': return self.hero_map.grid[(coor[0], coor[1]-length)] elif direction == 'right': return self.hero_map.grid[(coor[0], coor[1]+length)] except KeyError: # looking outside the map return 1 def check_wall(self, direction): """ Checks a space in given direction from the hero returns value of a grid: int: 0-7 """ return self.check_space(self.hero.coor, direction, 2) def push_wall(self, direction): """ Moves a wall near hero in given direction """ if direction == 'up': self.map.grid[self.hero.coor[0]-1, self.hero.coor[1]] = 0 self.map.grid[self.hero.coor[0]-2, self.hero.coor[1]] = 1 elif direction == 'down': self.map.grid[self.hero.coor[0]+1, self.hero.coor[1]] = 0 self.map.grid[self.hero.coor[0]+2, self.hero.coor[1]] = 1 elif direction == 'left': self.map.grid[self.hero.coor[0], self.hero.coor[1] - 1] = 0 self.map.grid[self.hero.coor[0], self.hero.coor[1] - 2] = 1 elif direction == 'right': self.map.grid[self.hero.coor[0], self.hero.coor[1] + 1] = 0 self.map.grid[self.hero.coor[0], self.hero.coor[1] + 2] = 1 def refresh_hero_map(self): self.hero_map = self.map.copy() if self.status != 3: self.hero_map.grid[self.hero.coor] = Game.directions[self.hero.direction] for troll in self.trolls: self.hero_map.grid[troll.coor] = 7 def win(self): """ After winning procedures: set Game.status, give a message to the player, set winning turn, clear trolls """ self.top_layer_on = True self.status = 2 # self.top_layer_map.clear_all() if self.turn - self.winning_turn == 1: self.change_top_layer(text="Seriously...You've already won\nR for restart") else: self.winning_turn = self.turn self.change_top_layer(text='You won!!!\nR for restart') self.clear_trolls() def is_lost(self): """ Check if game is lost: does any trolls's coordinates equals to hero coors """ for troll in self.trolls: if troll.coor == self.hero.coor: return True return False def lose(self): """ After losing procedures: set Game.status, give a message to player """ self.top_layer_on = True self.status = 3 self.change_top_layer(text="You've been eaten\nR for restart") def change_top_layer(self, text=None): """ Changes a message to player """ self.top_layer_map = Text_map(text=text) if text: self.top_layer_map.make_frame() self.top_layer_map.add_text() @staticmethod def new_coor(coor, direction, length=1): """Returns new coordinates based on given by coor and shifted by direction and length length: int; tells how far we are checking returns coor; (letter, number)""" assert direction in list(Game.directions.keys()) if direction == 'up': return (coor[0]-length, coor[1]) elif direction == 'down': return (coor[0]+length, coor[1]) elif direction == 'left': return (coor[0], coor[1] - length) elif direction == 'right': return (coor[0], coor[1] + length) @staticmethod def coors_dist(coor1, coor2): y_dist = abs(coor1[0] - coor2[0]) x_dist = abs(coor1[1] - coor2[1]) return y_dist + x_dist @staticmethod def objects_dist(object1, object2): y_dist = abs(object1.coor[0] - object2.coor[0]) x_dist = abs(object1.coor[1] - object2.coor[1]) return y_dist + x_dist
def showCost(self): plt.plot(np.arange(len(self.cost)), self.cost) plt.ylabel('Cost') plt.xlabel('training steps') plt.show() def update(): stepCounter = 0 for e in range(para.epoch): state = maze.reset() # 初始化 while True: maze.fresh() # 刷新环境(相当于显示) action = para.chooseAction(state) # 基于策略选择一个行动 newState, reward, isDone = maze.step(action) # 获得新棋盘状态,奖励和游戏是否结束 para.getInMemory(state, action, reward, newState) # 将过程存入缓存以便离线学习 if stepCounter > 200 and stepCounter % para.lsn == 0: # 每隔几步学习以此,抵消参数间的相关性 para.learn() if isDone: break state = newState stepCounter += 1 maze.destroy() if __name__ == "__main__": maze = Maze() # 建立迷宫环境 para = QParam(maze.n_actions, maze.n_features) # 初始化QL参数缺省值参数采用默认值 maze.after(100, update) # 循环100次 maze.mainloop() para.showCost()
if newState != 'terminal': QReal = reward + self.gamma * self.QTable.loc[newState, :].max() else: QReal = reward self.QTable.loc[state, action] += self.lr * (QReal - QPredict) def checkState(self, state): """ 若Q表中不存在该状态则将其添加进Q表,Q值初始化为0 """ if state not in self.QTable.index: self.QTable = self.QTable.append(pd.Series([0]*len(self.actions), index=self.actions, name=state)) def update(): for e in range(para.epoch): state = maze.reset() # 初始化 while True: maze.fresh() # 刷新环境(相当于显示) action = para.chooseAction(str(state)) # 基于策略选择一个行动 newState, reward, isDone = maze.step(action) # 获得新棋盘状态,奖励和游戏是否结束 para.learn(str(state), str(newState), action, reward) # 以字符串形式传递与tkinter有关,暂时还没了解 if isDone: break state = newState maze.destory() if __name__ == "__main__": maze = Maze() # 建立迷宫环境 para = QParam(actions=list(range(maze.n_actions))) # 初始化QL参数缺省值参数采用默认值 maze.after(para.epoch, update) # 循环100次 maze.mainloop()
def __init__(self, polygons, width, height, granularity, start, end): Maze.__init__(self, polygons, width, height, granularity, start, end)
class Game: def __init__(self): self._maze = Maze() self._player = Player(self._maze) pass def start(self): self.notify_first_player() while not self.game_ended(): self.draw() while self._player.steps_left > 0: self.wait_player_step() self.do_room_action() self.draw() self.notify_next_player() def load_maze(self): pass def draw(self): pass def wait_player_step(self): step_done = False while not step_done: direction = input('where move [(U)p, (L)eft, (R)ight, (D)own)? ').lower() if direction in ['u', 'up']: delta = (0, -1) elif direction in ['l', 'left']: delta = (-1, 0) elif direction in ['r', 'right']: delta = (1, 0) elif direction in ['d', 'down']: delta = (0, 1) else: print('wrong direction "{}"'.format(direction)) continue if self._player.move(delta): step_done = True else: print('cannot move in this direction.') def do_room_action(self): room = self._maze[self._player.position] if room.has_treasure(): self._player._treasure = True room.reset_feature() elif room.has_ammo(): self._player._ammo += 2 elif room.has_plant(): self._player._steps = -3 elif room.has_mine(): if self._player.has_treasure(): old_x, old_y = self._player.position treasure_placed = False while not treasure_placed: new_treasure_x = max(min(old_x + random.randint(-2, 2), 9), 0) new_treasure_y = max(min(old_y + random.randint(-2, 2), 9), 0) new_treasure_pos = (new_treasure_x, new_treasure_y) new_room = self._maze[new_treasure_pos] if not new_room.has_feature(): new_room._type = Room.TYPE_TREASURE treasure_placed = True new_x = random.randint(0, 9) new_y = random.randint(0, 9) self._player._pos = (new_x, new_y) elif room.has_exit(): pass room.reset_feature() def game_ended(self): return self._player.has_treasure() and \ self._player.position == self._maze.get_exit_point() def notify_next_player(self): if self._player._steps <= 0: self._player._steps += 3 def notify_first_player(self): self._player._steps = 3
class Move_Manager(object): def __init__(self): self._tw_pub = rospy.Publisher(TWIST_PUB, Twist) self._rate = rospy.Rate(RATE) self._checks = { Direction.FORWARD: None,\ Direction.LEFT: None,\ Direction.RIGHT: None,\ "ARRAY": None\ } self._sense_subs = [\ rospy.Subscriber(BUMPER_IO, TurtlebotSensorState, self._collision),\ rospy.Subscriber(SCAN_IO, Float64MultiArray, self._scan)\ ] self.maze = Maze() self._last_collision = None def debug(self, a=1): print(self._checks["ARRAY"]) # 1: right # 2: left # 3: both # just record that we hit something def _collision(self, data): # TODO return collisions = data.bumps_wheeldrops if collisions == 0 or self._last_collision is not None: return self.stop() self._send_twist(-COLLISION_X, 0) self._last_collision = collisions # executed when we have the chance def _handle_collision(self): self.maze.collision() self._last_collision = None # LaserScan callback def _scan(self, data): arr = data.data self._checks[Direction.RIGHT] = arr[0] self._checks[Direction.FORWARD] = arr[1] self._checks[Direction.LEFT] = arr[2] self._checks["ARRAY"] = arr # TODO: buggy # try to adjust the left and right side to be equidistant from an imaginary wall def center(self, count=1): if self._checks["ARRAY"] is None or \ self._checks[Direction.FORWARD] > MIN_DIST or \ count > CENTER_MAX_COUNT or\ not DO_CENTER: return num = count + 1 diff = self._checks[Direction.LEFT] - self._checks[Direction.RIGHT] # avoid adjustements that are too big (possibly just bad detection) # avoid minute adjustements if abs(diff) > CENTER_MAX_COUNT * CENTER_INC or \ abs(diff) < CENTER_TURN_DIST: return # HACK # guessing here, but we need to make a better decision here # should the robot turn towards or away from a wall? coeff = 1 if abs(diff) > CENTER_MAX_COUNT * CENTER_INC / 2: coeff = -1 self._send_twist(CENTER_FORWARD, 0) self._send_twist(0, coeff * CENTER_INC) self.center(count=num) # TODO # we don't want to be too close to a wall, we want to be in the center of a "cell" def not_too_close(self, count=1): if self._checks[Direction.FORWARD] < TOO_CLOSE and \ count < CLOSE_MAX_COUNT and \ DO_NOT_GET_CLOSE: self._send_twist(-BACKWARDS_X(CLOSE_INC), 0) c = count + 1 self.not_too_close(count=c) # turning is left to the callee! # if True, then the robot has enough room to perform the directional movement def check(self, direction, num=1): if direction == Direction.FORWARD: self.center() # check that we have room if self._checks[Direction.FORWARD] > MIN_DIST: # ok but are the sides confident? if not DO_GET_EDGE or self._checks[direction] > MIN_DIST: rospy.loginfo(self._checks) return True else: ## need to correct, ## lets nudge forward since we might be looking at a corner # if we are trying to go forward then this check is irrelevant if direction == Direction.FORWARD: rospy.loginfo(self._checks) return False # when middle says we are good # but the sides have something in front! elif direction == Direction.LEFT: if self._checks[direction] < MIN_DIST: self.move(Direction.RIGHT) self.move(Direction.FORWARD, scale=CHECK_SCALE) self.move(Direction.LEFT) else: self.move(Direction.LEFT) self.move(Direction.FORWARD, scale=CHECK_SCALE) self.move(Direction.RIGHT) return self.check(direction) # ^^ elif direction == Direction.RIGHT: if self._checks[direction] < MIN_DIST: self.move(Direction.LEFT) self.move(Direction.FORWARD, scale=CHECK_SCALE) self.move(Direction.RIGHT) else: self.move(Direction.RIGHT) self.move(Direction.FORWARD, scale=CHECK_SCALE) self.move(Direction.LEFT) return self.check(direction) rospy.loginfo(self._checks) return True else: rospy.loginfo(self._checks) return False # we always turn orthogonally so we won't ask for z input def move(self, direction, scale=1): if self._last_collision is not None: self._handle_collision() if direction == Turn.CLOCKWISE: direction = Direction.RIGHT if direction == Turn.COUNTER: direction = Direction.LEFT # NOTE this should be the only place where we delay after movement if direction == Direction.FORWARD: self._send_twist(TWIST_X / scale, 0) self.maze.step() self.center() self.not_too_close() elif direction == Direction.BACKWARD: # NOTE: backward is not just -TWIST_X self._send_twist(-BACKWARD(MAX_DIST) / scale, 0) elif direction == Direction.RIGHT or direction == Direction.LEFT: self._turn(direction) self.maze.turn(direction) self.center() else: rospy.loginfo("invalid direction to move() " + str(direction)) # halt movement of the turtlebot immediately def stop(self): twist = Twist() self._tw_pub.publish(twist) def _turn(self, direction): # an orthogonal turn on a flat surface # HACK right turns suck val = -(TWIST_Z * RIGHT_SCALE) if direction == Direction.RIGHT else ( LEFT_SCALE) * TWIST_Z self._send_twist(0, val) # actually send message # similar to what is found in turtlebot min_max tutorial def _send_twist(self, x, z): for _ in range(TWIST_NUM): twist = Twist() twist.linear.x = x twist.angular.z = z self._tw_pub.publish(twist) self._rate.sleep() self.stop() rospy.sleep(DELAY)
else: print('Incorrect run option\nTerminating') exit(0) print("Input file: ", image_path) print("Start coordinate: (" + str(x_start) + ', ' + str(y_start) + ')') print("End coordinate: (" + str(x_end) + ', ' + str(y_end) + ')') file_check = Path(image_path) # check that file exits if not file_check.is_file(): print("File does not exist, terminating") exit() print('-----------------------------') user_maze = Maze(image_path, (x_start, y_start), (x_end, y_end), show_history) if run_BFS: bfs_solution_image, bfs_duration, bfs_number_nodes = user_maze.solve_bfs( ) if bfs_number_nodes > 0: print( f'BFS algorithm found a solution in {bfs_duration:.3f} seconds' ) print(f'By visiting {bfs_number_nodes} nodes') if not save: bfs_solution_image.show() else: # save image save_path = 'maze_images/generated_solutions/' + image_path.split( '/')[-1].split('.')[0] + '_solutionBFS.png'
from BlindrobotProblem import BlindrobotProblem from Maze import Maze from astar_search import astar_search # null heuristic, useful for testing astar search without heuristic (uniform cost search). def null_heuristic(state): return 0 # test_maze2 = Maze("maze2.maz") # print test_maze2 # test_mp = BlindrobotProblem(test_maze2, (2, 2)) # result = astar_search(test_mp, test_mp.setsize_heuristic) # print result # test_mp.animate_path(result.path) test_maze07 = Maze("maze07.maz") print test_maze07 test_mp = BlindrobotProblem(test_maze07, (1, 0)) result = astar_search(test_mp, test_mp.setsize_heuristic) print result test_mp.animate_path(result.path)
def GenerateMaze(self, width, height, weights=None): # force weights to null for now if weights is None: use_weights = False weights = [1, 1, 1, 1] else: use_weights = True theMaze = Maze() theMaze.SetDimensions(width, height) # REWRITTEN AS OF 6/23 used_cells = np.zeros([height, width]) walls = [] # depth first starts at top left current_cell = [0, 0] used_cells[current_cell[0], current_cell[1]] = 1 # create adjacency list next_walls = [] borders = theMaze.GetBorders(current_cell) for index in xrange(len(borders)): if borders[index] == 0: new_cell = deepcopy(current_cell) if index == 0: new_cell[0] -= 1 elif index == 1: new_cell[1] += 1 elif index == 2: new_cell[0] += 1 elif index == 3: new_cell[1] -= 1 next_walls.append( [weights[index], current_cell, new_cell, index]) if not use_weights: while len(next_walls) > 0: wall_idx = randint(0, len(next_walls) - 1) wall = next_walls[wall_idx] next_walls.pop(wall_idx) walls.append(wall) else: next_walls_heaped = [] while len(next_walls) > 0: index, wall = ValueFromHeap(next_walls) next_walls_heaped.append(wall) next_walls_heaped.reverse() walls += next_walls_heaped # print "FIRST SET", adjacent_cells, maze_cells while len(walls) > 0: wall = walls[-1] walls = walls[:-1] if self.mVerbosity > 0: print "active wall (weight, from, to, direction): ", wall # ensure the cell this wall refers to is not in the maze prior_cell = wall[1] current_cell = wall[2] if used_cells[current_cell[0], current_cell[1]] == 1: if self.mVerbosity > 0: print " to cell in maze" continue used_cells[current_cell[0], current_cell[1]] = 1 # open the wall wallToOpen = wall[3] rWallToOpen = (wallToOpen + 2) % 4 theMaze.cells[prior_cell[0], prior_cell[1], wallToOpen] = 1 theMaze.cells[current_cell[0], current_cell[1], rWallToOpen] = 1 # create adjacency list next_walls = [] borders = theMaze.GetBorders(current_cell) for index in xrange(len(borders)): if borders[index] == 0: new_cell = deepcopy(current_cell) if index == 0: new_cell[0] -= 1 elif index == 1: new_cell[1] += 1 elif index == 2: new_cell[0] += 1 elif index == 3: new_cell[1] -= 1 next_walls.append( [weights[index], current_cell, new_cell, index]) if not use_weights: while len(next_walls) > 0: wall_idx = randint(0, len(next_walls) - 1) wall = next_walls[wall_idx] next_walls.pop(wall_idx) walls.append(wall) else: next_walls_heaped = [] while len(next_walls) > 0: index, wall = ValueFromHeap(next_walls) next_walls_heaped.append(wall) next_walls_heaped.reverse() walls += next_walls_heaped theMaze.end_cell = [0, 0] theMaze.start_cell = [theMaze.height - 1, theMaze.width - 1] return theMaze
if maze[startRow][startCol] == TRIED: return False # 3. Success, an outside edge not occupied by an obstacle if maze.isExit(startRow, startCol): maze.updatePosition(startRow, startCol, PART_OF_PATH) return True maze.updatePosition(startRow, startCol, TRIED) # Otherwise, use logical short circuiting to try each direction in turn # if needed. found = searchFrom(maze, startRow - 1, startCol) or \ searchFrom(maze, startRow + 1, startCol) or \ searchFrom(maze, startRow, startCol - 1) or \ searchFrom(maze, startRow, startCol + 1) if found: maze.updatePosition(startRow, startCol, PART_OF_PATH) else: maze.updatePosition(startRow, startCol, DEAD_END) return found mazeFile = "text_files/maze.txt" myMaze = Maze(mazeFile) myMaze.drawMaze() # Set turtle object to start point when executing search function. myMaze.updatePosition(myMaze.startRow, myMaze.startCol) searchFrom(myMaze, myMaze.startRow, myMaze.startCol) myMaze.wn.exitonclick()
def GenerateMaze(self, width, height, weights=None): if weights is None: use_weights = False weights = [1, 1, 1, 1] else: use_weights = True theMaze = Maze() theMaze.SetDimensions(width, height) # REWRITTEN AS OF 6/23 # I wrote this from a cell list which prevented me from using bias terms and weights. I've rectified that used_cells = np.zeros([height, width]) walls = [] # choose a start cell current_cell = [ np.random.randint(0, theMaze.height), np.random.randint(0, theMaze.width) ] used_cells[current_cell[0], current_cell[1]] = 1 # create adjacency list borders = theMaze.GetBorders(current_cell) for index in xrange(len(borders)): if borders[index] == 0: new_cell = deepcopy(current_cell) if index == 0: new_cell[0] -= 1 elif index == 1: new_cell[1] += 1 elif index == 2: new_cell[0] += 1 elif index == 3: new_cell[1] -= 1 walls.append([weights[index], current_cell, new_cell, index]) # print "FIRST SET", adjacent_cells, maze_cells while len(walls) > 0: # choose a wall to open if use_weights == False: wall_idx = randint(0, len(walls) - 1) wall = walls[wall_idx] walls.pop(wall_idx) else: index, wall = ValueFromHeap(walls) if self.mVerbosity > 0: print "active wall (weight, from, to, direction): ", wall # ensure the cell this wall refers to is not in the maze prior_cell = wall[1] current_cell = wall[2] if used_cells[current_cell[0], current_cell[1]] == 1: if self.mVerbosity > 0: print " to cell in maze" continue used_cells[current_cell[0], current_cell[1]] = 1 # open the wall wallToOpen = wall[3] rWallToOpen = (wallToOpen + 2) % 4 theMaze.cells[prior_cell[0], prior_cell[1], wallToOpen] = 1 theMaze.cells[current_cell[0], current_cell[1], rWallToOpen] = 1 # create adjacency list borders = theMaze.GetBorders(current_cell) for index in xrange(len(borders)): if borders[index] == 0: new_cell = deepcopy(current_cell) if index == 0: new_cell[0] -= 1 elif index == 1: new_cell[1] += 1 elif index == 2: new_cell[0] += 1 elif index == 3: new_cell[1] -= 1 walls.append( [weights[index], current_cell, new_cell, index]) theMaze.end_cell = [0, 0] theMaze.start_cell = [theMaze.height - 1, theMaze.width - 1] return theMaze
Main doesn't contain any method. They are all to be found either in Maze or Items modules Attributes in main: Main doesn't contain any attributes. They are all to be found either in Maze, or Items, or Config modules This program is based on Python 3.7.4 and Pygame 1.9.3 """ import pygame import Items import Config from Maze import Maze pygame.init() # Creates an instance to open a file containing the maze and build it up subsequently maze = Maze() maze.draw_maze(Config.maze_level) maze.display_objects() # Updates the maze_window pygame.display.flip() # Keeps the window open until intentionally closed running = True while running: # This loop goes through the 3 main phases of this game: movement, collect of the objects, exit the maze maze.macgyver.move(maze.walls, maze.window) maze.macgyver.collecting_item( maze.window, maze.objects_to_collect, maze.my_font) maze.macgyver.meeting_warden( maze.warden, maze.window, maze.my_font_end_game)
from MazeworldProblem import MazeworldProblem from MazeworldWithTimeFactorProblem import MazeworldProblemWithTimeFactor from Maze import Maze from astar_search import astar_search # null heuristic, useful for testing astar search without heuristic (uniform cost search). def null_heuristic(state): return 0 # Test problems test_maze3 = Maze("maze3.maz") test_mp = MazeworldProblem(test_maze3, (1, 4, 1, 3, 1, 2)) # print(test_mp.get_successors(test_mp.start_state)) # this should explore a lot of nodes; it's just uniform-cost search result = astar_search(test_mp, null_heuristic) print(result) # this should do a bit better: result = astar_search(test_mp, test_mp.manhattan_heuristic) print(result) # test_mp.animate_path(result.path) # Your additional tests here: maze_four = Maze("maze4corridor.maz") test_corridor = MazeworldProblem(maze_four, (2, 4, 2, 5, 2, 6))
from Runner import Runner pygame.init() # ------ Display ------ dis_width = 600 dis_height = 600 dis = pygame.display.set_mode((dis_width, dis_height)) dis.fill((255, 255, 255)) pygame.display.set_caption("Maze Path Finder") clock = pygame.time.Clock() fps = 360 # ------ Maze ------ maze = Maze(dis, dis_width) start = maze.get_start() maze.solve(start[0], start[1]) print(start) # ------ Runners ------ runner = Runner((start[1] * maze.block_size) + (maze.block_size / 2), (start[0] * maze.block_size) + (maze.block_size / 2), 10) count = 0 def gameLoop(count): running = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False dis.fill((255, 255, 255))
def __init__(self): self.maze = Maze() self.pacman = PacMan(1,1,self.maze)
def generateMazeList(): mazeList = list() for i in range(0, Demo.limit): mazeList.append(Maze()) return mazeList
mazeseed = [None] mazeseed = goodmazeseed seednum = 0 pygame.init() #mymazerunner = Mazerunner() black = (0, 0, 0) grey = (50, 50, 50) green = (0, 200, 0) red = (200, 0, 0) yellow = (255, 255, 0) screen = pygame.display.set_mode((500, 500)) pygame.display.set_caption('Random Maze') mymaze = Maze(screen, 41, 21, seed=mazeseed[seednum]) runner = Mazerunner(mymaze) print(mymaze) playing = True while playing: for event in pygame.event.get(): if event.type == pygame.QUIT: playing = False screen.fill(black) mymaze.draw() if runner is not None: r = runner.draw() if r == -1: seednum += 1
__author__ = 'rswoody' from Maze import Maze #generate 5 mazes total_mazes = 5 maze_index = 0 while maze_index < total_mazes: maze = Maze(10, 10) maze.generate() maze.print_maze("maze" + str(maze_index + 1)) maze_index += 1 print("Complete")
self.updateH(CLOSED, goal) if OPEN.isEmpty(): # open list is empty print("Cannot reach target") m.pprint(ZZ) return path = self.reversePath(start, goal) zero = path[0] self.moveTo(zero) ZZ[zero.x][zero.y] = 1 self.lookAround(zero, m) last = None for s in path[1:]: # moves agent, goes in proper order and checks for isBlocked if not s.isBlocked: self.moveTo(s) ZZ[s.x][s.y] = 1 m.pprint(ZZ, close=True) self.lookAround(s, m) last = s else: break if last is not None and goal.x != last.x and goal.y != last.y: start = last print("target reached") m.pprint(ZZ) if __name__ == "__main__": m = Maze() agent = aAgent(m.sx, m.sy, m.gx, m.gy) agent.adaptiveA(m)
def __init__(self, width, height): self.__maze = Maze(width, height)
'weight': 'normal', 'size': 22} plt.ylabel('Average Throughput', font2) plt.xlabel('Training Episodes', font2) plt.savefig('average_migration.eps', bbox_inches='tight') plt.show() """ plt.figure(1) plt.plot(np.arange(len(remark)), remark) plt.xlabel("Total Episodes") plt.ylabel("Average Return") plt.figure(2) plt.plot(np.arange(len(average_migration)), average_migration) plt.xlabel("Total Episodes") plt.ylabel("Average Throughput") plt.show() """ print('game over') env.destroy() if __name__ == "__main__": env = Maze() RL = Dream(actions=list(range(env.n_actions))) env.after(100, update) env.mainloop()
plt.show() """ env.reset_uav() env.render() end = time.time() print("game over!") print('运行时间:', end - start) engine = pyttsx3.init() engine.say('程序运行完成') engine.runAndWait() env.destory() if __name__ == "__main__": env = Maze() RL1 = DeepQNetwork1(env.n_actions, env.n_features, learning_rate=0.01, reward_decay=0.9, e_greedy=0.9, replace_target_iter=200, # 尝试减少替换次数 memory_size=2000, # 尝试扩大记忆库 output_graph=False ) RL2 = DeepQNetwork2(env.n_actions, env.n_features, learning_rate=0.01, reward_decay=0.9, e_greedy=0.9, replace_target_iter=180, # 尝试减少替换次数 memory_size=1800, # 尝试扩大记忆库
class Game(StateMachine): def __init__(self,gridSize=32,frameRate=60): super(Game,self).__init__('TheGame.You Lost It.') pygame.init() self.framerate = frameRate self.maze = Maze(gridSize) self.maze.read("theMaze") self.screen = pygame.display.set_mode(self.maze.rect.size,0,32) self.clock = pygame.time.Clock() self.paused = False self.add(AttractMode(self)) self.add(SetupLevelMode(self)) self.add(PlayingMode(self)) self.add(IntermissionMode(self)) self.add(GameOverMode(self)) self.setStateByName(PlayingMode.name) @property def time(self): ms = self.clock.tick(self.framerate) return ms / 1000.0 @property def font(self): try: return self._font except AttributeError: pass self._font = pygame.font.Font(FONTNAME,self.maze.gridWidth) return self._font @property def highScoreLabel(self): try: return self._highScoreLabel except AttributeError: pass self._highScoreLabel = self.font.render("HIGH SCORE", True, (255,255,255),(0,0,0)) return self._highScoreLabel @property def oneUpLabel(self): try: return self._oneUpLabel except AttributeError: pass self._oneUpLabel = self.font.render("1UP", True, (255,255,255),(0,0,0)) return self._oneUpLabel @property def twoUpLabel(self): try: return self._twoUpLabel except AttributeError: pass self._twoUpLabel = self.font.render("2UP", True, (255,255,255),(0,0,0)) return self._twoUpLabel @property def readyLabel(self): try: return self._readyLabel except AttributeError: pass self._readyLabel = self.font.render("Ready!", True, (255,255,0),(0,0,0)) return self._readyLabel def start(self): pass def up(self): self.maze.puckman.newHeading = UP def down(self): self.maze.puckman.newHeading = DOWN def left(self): self.maze.puckman.newHeading = LEFT def right(self): self.maze.puckman.newHeading = RIGHT def pause(self): self.paused = True def unpause(self): self.paused = False def run(self): while True: self.think() def quit(self): print "quitting" exit() def drawHighScore(self): lrect = self.highScoreLabel.get_rect() srect = self.screen.get_rect() lrect.midtop = srect.midtop self.screen.blit(self.highScoreLabel,lrect.topleft) def draw1UpScore(self,score): r = self.screen.get_rect() scoreText = self.font.render("%d" % score, True, (255,255,0),(0,0,0)) lrect = scoreText.get_rect() x,y = r.midtop x /= 4 y += self.maze.gridWidth lrect.midtop = (x,y) self.screen.blit(scoreText,lrect.topleft) def draw1Up(self): lrect = self.oneUpLabel.get_rect() srect = self.screen.get_rect() x,y = srect.midtop x /= 2 lrect.midtop = (x,y) self.screen.blit(self.oneUpLabel,lrect.topleft) def draw2Up(self): pass def drawFruit(self): pass def update(self): if self.paused: self.time else: self.maze.update(self.time) def draw(self): self.maze.draw(self.screen) self.drawHighScore() self.draw1Up() self.draw1UpScore(self.maze.puckman.score) self.draw2Up() self.drawFruit()