Before learning path calculation, we need a scene. We checked the maze generation method online and spent some time writing a simple maze generator

The basic principle is very simple:

The 2-dimensional matrix is used to represent the maze. Each node has four walls. The depth search is used to move in four directions randomly. If the node is reached, the direction will be stopped, and the wall between the two nodes will be eliminated. This can ensure that each node can be covered, and each node will have a way to the exit.

A simple algorithm has an obvious disadvantage: each node has only one fixed path, and there will be no multiple paths to a node.

The use of recursion in deep search is very concise and will not be repeated.

Specifically, where it is easy to suffer from pits, how to simply move up, down, left and right randomly, eliminate walls, and do not need a thousand if:

The first is the direction representation, which uses a list:

directions = [[0,-1],[1,0],[0,1],[-1,0]]

They represent upper right lower left respectively

Use random for [0,1,2,3] Shuffle () function, and then traverse the list to obtain the upper, lower, left and right vectors at random

Each node has four walls, expressed by [0,0,0,0], and the sequence direction is the same as the above direction.

When eliminating the wall between one node, you need to eliminate the node on the opposite side of the previous wall

Or operate on the direction. direction[i] expresses the direction vector. Here, the plus sign is to move to the right, rotate 45 degrees clockwise when moving one bit to the right, and rotate 45 degrees counterclockwise when moving one bit to the left

If the number i is shifted 2 bits to the right and projected onto 0-3, the direction can be changed.

Simply put, it is to move right and divide the remainder

During each search, if a node that has been accessed before is encountered, exit the function. The covered nodes are recorded in the function. If the total number of nodes is reached, exit directly

The operation effect is as follows:

We can see the characteristics of the recursive depth first algorithm: it will return to the previous node after the end of a road

import pygame as pg import time import random class Tile(): def __init__(self,grid_size,screen_size,x,y): #It mainly stores data and draws graphics, which has nothing to do with the algorithm self.x,self.y = x,y self.connected = [0,0,0,0] # up,right,down,left 0 for not connected self.grid_size = grid_size self.tile_size = [(screen_size[0]-100)/grid_size[0],(screen_size[1]-100)/grid_size[1]] self.rectangle = (self.x*self.tile_size[0]+50,self.y*self.tile_size[1]+50,self.tile_size[0],self.tile_size[1]) self.points = [ [self.x*self.tile_size[0]+50,self.y*self.tile_size[1]+50], #uppper left [self.x*self.tile_size[0]+50+self.tile_size[0],self.y*self.tile_size[1]+50], #upper right [self.x*self.tile_size[0]+50+self.tile_size[0],self.y*self.tile_size[1]+50+self.tile_size[1]], #lower right [self.x*self.tile_size[0]+50,self.y*self.tile_size[1]+50+self.tile_size[1]], #lower left ] self.visited = False def draw(self,color = (255,253,150)): #x,y represents the tile coordinates pg.draw.rect(screen,color,self.rectangle) #Draw node for i in range(4): #Draw four walls if not self.connected[i]: pg.draw.line(screen,(150,175,255),(self.points[i]),(self.points[((i+1)%4)]),5) def maze_gen(path): global tile_covered #Number of overlay nodes. When the number of overlay nodes reaches the number of grids, it will stop x,y = path[-1] if x < 0 or x >= grid_size[0] or y < 0 or y >= grid_size[1]: #Exit if out of grid range print(f'index out of range at {x,y}') return matrix[y][x].draw() if matrix[y][x].visited: #Exit if the node has been accessed print(f'node already visited at {x,y}') return elif tile_covered <= grid_size[0]*grid_size[1]: #The number of overlay nodes does not reach the total number of grids tile_covered += 1 matrix[y][x].visited = True path_choice = [0,1,2,3] random.shuffle(path_choice) directions = [[0,-1],[1,0],[0,1],[-1,0]] # up,right,down,left 0 for not connected for i in path_choice: x_,y_ = x+directions[i][0],y+directions[i][1] path.append([x_,y_]) if maze_gen(path): matrix[y][x].connected[i] = 1 #walls of current node matrix[y_][x_].connected[(i+2)%4] = 1#reverse the vector direction matrix[y][x].draw() matrix[y_][x_].draw() path.pop(-1) pg.display.update() return True else: print('all node visited') return screen_size = [800,800] grid_size = [40,40] exit = [10,10] tile_covered = 0 run = True screen = pg.display.set_mode(screen_size) matrix = [] for y in range(grid_size[1]): #Create a two-dimensional matrix, where x and Y represent coordinates temp = [] for x in range(grid_size[0]): tile = Tile(grid_size,screen_size,x,y) temp.append(tile) matrix.append(temp) pg.init() path = [[0,0]] screen.fill((255,255,255)) maze_gen(path) pg.display.update() print('======== Generation Finished ========') while run: #Do not exit after weighing, use the cycle for event in pg.event.get(): if event.type == pg.QUIT: time.sleep(0.1) pg.quit() exit()