猫史档案馆

【作品展示】

 

【作品介绍】

难度等级：1.简单 2.中等 3.困难 4.青铜 5.钻石 6.王者

 

【作品源代码】

import random
import pygame
import numpy as np

#Re喵blog/2018/11/18/Build-a-2-player-maze-game-with-Python-Part-4/
UP, DOWN = -1, 1
LEFT, RIGHT = -2, 2

我 = input('难度等级：1.简单 2.中等 3.困难 4.青铜 5.钻石 6.王者(写数字选项)')
if (我 == '1'):
    我, a, b ,c= 喵
if (我 == '2'):
    我, a, b, c = 30, 26, 240, 1000
if (我 == '3'):
    我, a, b, c = 60, 52, 250, 1000
if (我 == '4'):
    我, a, b, c = 120, 104, 300, 1000
if (我 == '5'):
    我, a, b, c = 240, 208, 400, 1000
if (我 == '6'):
    我, a, b ,c= 470, 250, 480, 1910
SCREEN_WIDTH = c
SCREEN_HEIGHT = 1000

MAZE_COLS = 我
MAZE_ROWS = a
WALL_SIZE = int(b/max(MAZE_COLS, MAZE_ROWS))  # Pixel size/Wall thickness
WT = WALL_SIZE  # used in pygame.time.wait(WT)
CELL_SIZE = 4*WALL_SIZE  # a cell has only 2 walls: DOWN, RIGHT
MAZE_WIDTH = CELL_SIZE * MAZE_COLS + WALL_SIZE
MAZE_HEIGHT = CELL_SIZE * MAZE_ROWS + WALL_SIZE

TOPLEFT_X, TOPLEFT_Y = (SCREEN_WIDTH // 2 - MAZE_WIDTH //2, SCREEN_HEIGHT // 2 - MAZE_HEIGHT // 2)
x_offset = TOPLEFT_X + WALL_SIZE
y_offset = TOPLEFT_Y + WALL_SIZE

WALL_COLOR = (18, 94, 32)
MAZE_COLOR = (255, 255, 255)
UNVISITED_COLOR = (0, 0, 0)
PLAYER_COLOR = (255, 0, 0)

SHOW_DRAW = True


class Cell():
    def __init__(self, r, c):
        self.r = r
        self.c = c
        self.visited = False  # True-just visited, not open any wall
        self.walls = {UP: False, DOWN: False, LEFT: False, RIGHT: False}


class Maze():
    def __init__(self, row=MAZE_ROWS, col=MAZE_COLS):
        self.row = row
        self.col = col
        self.maze = [[Cell(r, c) for c in range(col)] for r in range(row)]
        self.make()
        self.player = Player(PLAYER_COLOR, (WALL_SIZE * 3) // 2)
        self.player_sprite = pygame.sprite.RenderPlain(self.player)

    def make(self, r0=0, c0=0):
        direction = {UP: (-1, 0), DOWN: (1, 0), LEFT: (0, -1), RIGHT: (0, 1)}
        current_cell = self.maze[r0][c0]
        current_cell.visited = True
        visited_stack = [current_cell]
        while visited_stack:
            current_cell = visited_stack[-1]
            un_visited = []  # unvisited neighbours
            for d, (dr, dc) in direction.items():
                r, c = current_cell.r + dr, current_cell.c + dc
                if (0 <= r < self.row) and (0 <= c < self.col):
                    cell = self.maze[r][c]
                    if not cell.visited:
                        un_visited.append((d, cell))
            if un_visited:
                dc, nc = random.choice(un_visited)
                current_cell.walls[dc] = True  # this direction is open
                nc.visited = True
                nc.walls[-dc] = True
                visited_stack.append(nc)
            elif len(visited_stack):
                visited_stack.pop()

            if SHOW_DRAW:
                self.draw_maze()
                pygame.display.update()
                pygame.time.wait(WT)
                pygame.event.pump()

        #self.maze[0][0].walls[LEFT]=True
        #self.maze[self.row-1][self.col-1].walls[RIGHT] = True

    def draw_maze(self):
        
        pygame.draw.rect(screen, WALL_COLOR, (TOPLEFT_X,
                         TOPLEFT_Y, MAZE_WIDTH, MAZE_HEIGHT))
        for c in range(MAZE_COLS):  # colums 5 x-c
            for r in range(MAZE_ROWS):  # rows 3 y-r
                cell = self.maze[r][c]
                x = c*CELL_SIZE + x_offset
                y = r*CELL_SIZE + y_offset
                if cell.visited:
                    pygame.draw.rect(screen, MAZE_COLOR,
                                     (x, y, 3*WALL_SIZE, 3*WALL_SIZE))
                else:
                    pygame.draw.rect(screen, UNVISITED_COLOR,
                                     (x, y, 3*WALL_SIZE, 3*WALL_SIZE))
                if cell.walls[DOWN]:
                    pygame.draw.rect(screen, MAZE_COLOR,
                                     (x, y+3*WALL_SIZE, 3*WALL_SIZE, WALL_SIZE))
                if cell.walls[RIGHT]:
                    pygame.draw.rect(screen, MAZE_COLOR,
                                     (x+3*WALL_SIZE, y, WALL_SIZE, 3*WALL_SIZE))

    def can_move(self, direction):
        c = self.player.c
        r = self.player.r
        return self.maze[r][c].walls[direction]

    def checkEvents(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                exit()
            elif event.type == pygame.KEYDOWN:  # 判断键盘事件
                if event.key == pygame.K_UP or event.key == pygame.K_w:
                    direction = "w"
                    if self.can_move(UP):
                        self.player.r -= 1
                elif event.key == pygame.K_DOWN or event.key == pygame.K_s:
                    direction = "s"
                    if self.can_move(DOWN):
                        self.player.r += 1
                elif event.key == pygame.K_LEFT or event.key == pygame.K_a:
                    direction = "a"
                    if self.can_move(LEFT):
                        self.player.c -= 1
                elif event.key == pygame.K_RIGHT or event.key == pygame.K_d:
                    direction = "d"
                    if self.can_move(RIGHT):
                        self.player.c += 1
                elif event.key == K_ESCAPE:
                    pygame.event.post(pygame.event.Event(QUIT))

    def update(self):
        self.draw_maze()
        #self.draw_grid()
        self.player.update()
        self.player_sprite.draw(screen)


class Player(pygame.sprite.Sprite):
    def __init__(self, color, radius, r=0, c=0):
        # Call the parent class (Sprite) constructor
        super().__init__()
        self.r = r
        self.c = c
        self.image = pygame.Surface([radius * 2, radius * 2])
        self.image.fill(MAZE_COLOR)
        self.image.set_colorkey(MAZE_COLOR)
        pygame.draw.circle(self.image, color, (radius, radius), radius)
        self.rect = self.image.get_rect()
        self.update()

    def update(self):
        self.rect.x = x_offset+self.c*CELL_SIZE
        self.rect.y = y_offset+self.r*CELL_SIZE


pygame.init()
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
A = Maze()
while 1:
    screen.fill((0, 0, 0))
    A.checkEvents()
    A.update()
    pygame.display.update()

 

【提示】

部分含有Python第三方库相关内容的作品，在海龟编辑器网页端无法运行哦！如遇到这种情况，可以打开下面的链接，下载海龟编辑器客户端：

https://python.codemao.cn