仲骏逸————迷宫游戏

仲骏逸

[Python] 纯文本查看 复制代码

import pygame
import random
import sys

# 游戏设置
WIDTH, HEIGHT = 800, 600
CELL_SIZE = 20
MAZE_WIDTH = WIDTH // CELL_SIZE
MAZE_HEIGHT = HEIGHT // CELL_SIZE
FPS = 15  # 每秒帧数

# 颜色定义
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
YELLOW = (255, 255, 0)

# 初始化pygame
pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("迷宫游戏")
clock = pygame.time.Clock()


class Player:
    def __init__(self):
        self.x, self.y = 1, 1
        self.score = 0

    def move(self, dx, dy, maze):
        if maze[self.y + dy][self.x + dx] == 0:
            self.x += dx
            self.y += dy


class Enemy:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def move(self, player_pos, maze):
        dx, dy = 0, 0
        if self.x < player_pos[0]:
            dx = 1
        elif self.x > player_pos[0]:
            dx = -1
        if self.y < player_pos[1]:
            dy = 1
        elif self.y > player_pos[1]:
            dy = -1

        # 移动，确保进入的单元是通路
        if maze[self.y + dy][self.x + dx] == 0:
            self.x += dx
            self.y += dy


def generate_maze(width, height):
    maze = [[1] * width for _ in range(height)]

    for x in range(1, width, 2):
        for y in range(1, height, 2):
            maze[y][x] = 0

    for y in range(1, height - 1, 2):
        for x in range(1, width - 1, 2):
            direction = random.choice([(1, 0), (0, 1)])
            if direction == (1, 0):  # Horizontal
                maze[y][x + 1] = 0
            else:  # Vertical
                maze[y + 1][x] = 0

    # 添加随机障碍物
    for _ in range(random.randint(10, 30)):
        x, y = random.randint(1, width - 2), random.randint(1, height - 2)
        if maze[y][x] == 0:
            maze[y][x] = 1

    return maze


def draw_maze(maze, player, enemies, items):
    screen.fill(WHITE)
    for y in range(len(maze)):
        for x in range(len(maze[y])):
            color = BLACK if maze[y][x] == 1 else WHITE
            pygame.draw.rect(screen, color, (x * CELL_SIZE,
                             y * CELL_SIZE, CELL_SIZE, CELL_SIZE))

    pygame.draw.rect(screen, GREEN, (player.x * CELL_SIZE,
                     player.y * CELL_SIZE, CELL_SIZE, CELL_SIZE))  # 玩家

    for enemy in enemies:
        pygame.draw.rect(screen, RED, (enemy.x * CELL_SIZE,
                         enemy.y * CELL_SIZE, CELL_SIZE, CELL_SIZE))  # 敌人

    for item in items:
        pygame.draw.rect(
            screen, BLUE, (item[0] * CELL_SIZE, item[1] * CELL_SIZE, CELL_SIZE, CELL_SIZE))  # 物品


def main():
    maze = generate_maze(MAZE_WIDTH, MAZE_HEIGHT)
    player = Player()
    enemies = [Enemy(random.randint(1, MAZE_WIDTH - 2),
                     random.randint(1, MAZE_HEIGHT - 2)) for _ in range(3)]

    # 生成物品
    items = []
    while len(items) < 5:
        item = (random.randint(1, MAZE_WIDTH - 2),
                random.randint(1, MAZE_HEIGHT - 2))
        if item not in items and maze[item[1]][item[0]] == 0:
            items.append(item)

    exit_pos = (MAZE_WIDTH - 2, MAZE_HEIGHT - 2)

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()

        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:
            player.move(-1, 0, maze)
        if keys[pygame.K_RIGHT]:
            player.move(1, 0, maze)
        if keys[pygame.K_UP]:
            player.move(0, -1, maze)
        if keys[pygame.K_DOWN]:
            player.move(0, 1, maze)

        # 敌人移动
        for enemy in enemies:
            enemy.move((player.x, player.y), maze)

        # 检查玩家是否被抓住
        for enemy in enemies:
            if (player.x, player.y) == (enemy.x, enemy.y):
                print(f"游戏结束！你的得分: {player.score}")
                pygame.quit()
                sys.exit()

        # 收集物品
        items = [item for item in items if item != (player.x, player.y)]
        player.score += (5 - len(items)) * 10  # 每收集一个物品得10分

        # 绘制迷宫
        draw_maze(maze, player, enemies, items)

        # 检查是否到达出口
        if (player.x, player.y) == exit_pos:
            print(f"恭喜！你成功逃脱，得分: {player.score}")
            pygame.quit()
            sys.exit()

        pygame.display.flip()
        clock.tick(FPS)


if __name__ == '__main__':
    main()

admin

[Python] 纯文本查看 复制代码

import pygame
import random

# 初始窗口大小
INIT_WIDTH, INIT_HEIGHT = 800, 600
BLOCK_SIZE = 20

# 颜色定义
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)

# 初始化 Pygame
pygame.init()
screen = pygame.display.set_mode((INIT_WIDTH, INIT_HEIGHT), pygame.RESIZABLE)
pygame.display.set_caption("迷宫小游戏")
clock = pygame.time.Clock()

# 迷宫类


class Maze:
    def __init__(self, rows, cols):
        self.rows = rows
        self.cols = cols
        self.maze = [[1] * (2 * cols + 1) for _ in range(2 * rows + 1)]
        self.generate_maze()

    def generate_maze(self):
        stack = []
        start_x, start_y = 1, 1
        self.maze[start_y][start_x] = 0
        stack.append((start_x, start_y))

        while stack:
            x, y = stack[-1]
            neighbors = []
            if x > 1 and self.maze[y][x - 2] == 1:
                neighbors.append((x - 2, y))
            if x < 2 * self.cols - 1 and self.maze[y][x + 2] == 1:
                neighbors.append((x + 2, y))
            if y > 1 and self.maze[y - 2][x] == 1:
                neighbors.append((x, y - 2))
            if y < 2 * self.rows - 1 and self.maze[y + 2][x] == 1:
                neighbors.append((x, y + 2))

            if neighbors:
                next_x, next_y = random.choice(neighbors)
                self.maze[(y + next_y) // 2][(x + next_x) // 2] = 0
                self.maze[next_y][next_x] = 0
                stack.append((next_x, next_y))
            else:
                stack.pop()

        # 设置起点和终点
        self.maze[1][1] = 0
        self.end_x = 2 * self.cols - 1
        self.end_y = 2 * self.rows - 1
        self.maze[self.end_y][self.end_x] = 0

    def draw(self, screen, block_size):
        for y in range(len(self.maze)):
            for x in range(len(self.maze[0])):
                if self.maze[y][x] == 1:
                    pygame.draw.rect(
                        screen, BLACK, (x * block_size, y * block_size, block_size, block_size))

# 玩家类


class Player:
    def __init__(self, x, y):
        self.grid_x = x
        self.grid_y = y
        self.x = x * BLOCK_SIZE + BLOCK_SIZE // 2
        self.y = y * BLOCK_SIZE + BLOCK_SIZE // 2
        self.target_x = self.x
        self.target_y = self.y
        self.speed = 5

    def move(self, dx, dy, maze):
        new_grid_x = self.grid_x + dx
        new_grid_y = self.grid_y + dy
        if 0 <= new_grid_x < 2 * maze.cols + 1 and 0 <= new_grid_y < 2 * maze.rows + 1 and maze.maze[new_grid_y][new_grid_x] == 0:
            self.grid_x = new_grid_x
            self.grid_y = new_grid_y
            self.target_x = new_grid_x * BLOCK_SIZE + BLOCK_SIZE // 2
            self.target_y = new_grid_y * BLOCK_SIZE + BLOCK_SIZE // 2

    def update(self):
        if self.x < self.target_x:
            self.x = min(self.x + self.speed, self.target_x)
        elif self.x > self.target_x:
            self.x = max(self.x - self.speed, self.target_x)
        if self.y < self.target_y:
            self.y = min(self.y + self.speed, self.target_y)
        elif self.y > self.target_y:
            self.y = max(self.y - self.speed, self.target_y)

    def draw(self, screen):
        pygame.draw.circle(
            screen, RED, (int(self.x), int(self.y)), BLOCK_SIZE // 2 - 2)


# 初始化关卡
level = 1

# 根据初始窗口大小计算行数和列数
ROWS = INIT_HEIGHT // BLOCK_SIZE
COLS = INIT_WIDTH // BLOCK_SIZE

# 创建迷宫和玩家
maze = Maze(ROWS, COLS)
player = Player(1, 1)

# 游戏主循环
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.VIDEORESIZE:
            # 窗口大小改变时，重新计算块大小
            new_width, new_height = event.size
            screen = pygame.display.set_mode(
                (new_width, new_height), pygame.RESIZABLE)
            BLOCK_SIZE = min(new_width // (2 * COLS + 1),
                             new_height // (2 * ROWS + 1))
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_UP:
                player.move(0, -1, maze)
            elif event.key == pygame.K_DOWN:
                player.move(0, 1, maze)
            elif event.key == pygame.K_LEFT:
                player.move(-1, 0, maze)
            elif event.key == pygame.K_RIGHT:
                player.move(1, 0, maze)

    # 更新玩家位置
    player.update()

    # 绘制背景
    screen.fill(WHITE)

    # 绘制迷宫
    maze.draw(screen, BLOCK_SIZE)

    # 绘制玩家
    player.draw(screen)

    # 绘制终点
    pygame.draw.rect(screen, GREEN, (maze.end_x * BLOCK_SIZE,
                     maze.end_y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE))

    # 检查是否到达终点
    if player.grid_x == maze.end_x and player.grid_y == maze.end_y:
        print(f"恭喜你，成功通过第 {level} 关！")
        level += 1
        # 生成新的迷宫
        maze = Maze(ROWS, COLS)
        # 重置玩家位置
        player = Player(1, 1)

    # 更新显示
    pygame.display.flip()
    clock.tick(60)

# 退出 Pygame
pygame.quit()