[pyGame games] I'm not afraid you can't walk the maze series: the ultimate AI walks the maze. After learning, it will take you to open the door to a new world ~ (with game source code)

Preface

author ：“ Programmer pear ”

** The article brief introduction **： This article is mainly about pygame Realization AI Gobang version of the game ！

** article Source code Free access ： To thank every project that pays attention to my little cute article Source code It's all nothing

Compensation sharing drop

Click here for the blue line font , If you need any source code, remember to say the title and name ！ I can also ！

Welcome friends give the thumbs-up 、 Collection 、 Leaving a message.

Text

hello ！ Hello, I'm a pear , Here comes the daily update ——

Have you ever played maze games ？ Usually when I was a child , The elders of the family will play with the children of the family

Some parent-child games 、 For example, the most familiar one 《 Maze games 》 La ~ It's great to exercise your brain ！

today , Let's use our imagination , Together with the code to make a AI Version of the maze ！

 

One 、 Game ideas

This small program solves the maze problem with recursive method , Added a maze that can be automatically generated , But some problems are not very clear

The maze used a stupid method , It's generating 20 That's ok 、 It will be slow to list the mazes above ~

Just a simple study , After that, there will be better ones to continue to learn and update them for you ！

1） Effect display

2） The main program

There are three main codes , There are too many, so only the code of the main program is shown here , Official account at the end of the article. ！

import random
import pygame

FPS = 60
ROW = 10
COL = 10
BLOCK = 20
BORDER = 20
SCREEN_WIDTH = COL * BLOCK + BORDER * 2
SCREEN_HEIGHT = ROW * BLOCK + BORDER * 2
IMPOSSIBLE_COLOR = (128, 128, 128)
POSSIBLE_COLOR = (76, 141, 174)
ROUTE_COLOR = (12, 137, 24)


# noinspection PyPep8Naming
class DrawMaze(object):
    def __init__(self):
        self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))    #  Create screen object 
        pygame.display.set_caption('{}*{} Maze'.format(ROW, COL))               #  Window title 
        self.clock = pygame.time.Clock()
        self.color = POSSIBLE_COLOR                 #  First, set the color of the path block to be the same as that of the possible block 
        self.maze = MakeMaze().create(ROW, COL)
        self.no_route = True

    def display(self):
        """  Show maze in window , Press any key to display the path  """
        while True:
            self.screen.fill((0, 0, 0))
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    exit()
                if event.type == pygame.MOUSEBUTTONDOWN:    #  Press the mouse to display the path , Press again to cancel the display 
                    if self.no_route:
                        self.color = ROUTE_COLOR
                        self.no_route = False
                    else:
                        self.color = POSSIBLE_COLOR
                        self.no_route = True
                if event.type == pygame.KEYDOWN:            #  Press any key to regenerate the maze 
                    self.maze = MakeMaze().create(ROW, COL)

            self.drawBlock(self.color)
            self.clock.tick(FPS)
            pygame.display.update()

    def drawBlock(self, color):
        """  Take out the maze data with traversal and draw color blocks in the window  """
        for i, line in enumerate(self.maze):
            for j, value in enumerate(line):
                rect = (j * BLOCK + BORDER, i * BLOCK + BORDER, BLOCK, BLOCK)
                if value == 0:
                    pygame.draw.rect(self.screen, IMPOSSIBLE_COLOR, rect, 0)
                elif value == 1:
                    pygame.draw.rect(self.screen, POSSIBLE_COLOR, rect, 0)
                else:
                    pygame.draw.rect(self.screen, color, rect, 0)


# noinspection PyPep8Naming
class MakeMaze(object):
    def __init__(self):
        self.route_list = []        #  Initialize route list 

    # noinspection PyUnusedLocal
    def create(self, x, y):
        """  Create mazes  """
        route_list = []  #  Initialize route list 
        while True:
            maze = [[random.choice([0, 1]) for j in range(y)] for i in range(x)]
            maze[0][0] = 1
            if self.walk(maze, 0, 0):
                return maze

    def walk(self, maze, x, y):
        """
         If the location is the exit of the maze , It shows that you have successfully walked out of the maze 
         Down in turn 、 Right 、 Left 、 Detect on , Go through and return True, Then continue the detection , Go back if you can't get through False
        """
        if x == len(maze) - 1 and y == len(maze[0]) - 1:
            maze[x][y] = 2                      #  Mark the exit position 
            return True

        if self.validPos(maze, x, y):           #  Recursive principal implementation 
            self.route_list.append((x, y))      #  Add location to route list 
            maze[x][y] = 2                      #  Make a mark , Prevent folding back 
            if self.walk(maze, x + 1, y) or self.walk(maze, x, y + 1) \
                    or self.walk(maze, x, y - 1) or self.walk(maze, x - 1, y):
                return True
            else:
                maze[x][y] = 1                  #  If you fail to get through, cancel the position mark of the previous step , So that it can be returned 
                self.route_list.pop()           #  Deletes a location from the location list , The last element 
                return False
        return False

    @staticmethod
    def pprint(maze):
        """  Print maze  """
        [print(n) for n in maze]

    @staticmethod
    def validPos(maze, x, y):
        """  Judge the validity of coordinates , If it exceeds the array boundary or does not meet the requirements, the value is 1 Conditions , Description this point is invalid. Return False, Otherwise return to True """
        if len(maze) > x >= 0 and len(maze[0]) > y >= 0 and maze[x][y] == 1:
            return True
        else:
            return False


def main():
    drawer = DrawMaze()                 #  Generating drawing objects with maze 
    drawer.display()                    #  Show maze 


if __name__ == '__main__':
    main()

summary

An LA ！ This is the article , Your support is my biggest motivation , Remember Sanlian ~

Follow Xiaobian for more wonderful content ！ Remember to click on the portal

Remember Sanlian ！ If you need to package the complete source code + Free sharing of materials ！ Portal