使用 Pygame 构建飞扬的小鸟游戏

介绍

在这个项目中，我们将把使用 Pygame 库创建一个简单的《飞扬的小鸟》游戏的代码分解为可管理的步骤。通过遵循这些步骤，你将学习如何逐步构建这个游戏。每个步骤都将包括简要解释、代码块和注释，以帮助你理解和实现这个游戏。让我们开始吧！

👀 预览

🎯 任务

在这个项目中，你将学习：

• 如何为《飞扬的小鸟》游戏设置项目文件
• 如何展示游戏的欢迎动画
• 如何实现《飞扬的小鸟》的主要游戏逻辑
• 当玩家失败时如何显示游戏结束画面
• 如何为游戏定义辅助函数

🏆 成果

完成这个项目后，你将能够：

• 使用 Pygame 库创建游戏
• 理解游戏开发概念，如游戏循环、碰撞和动画

创建项目文件

首先，我们将为《飞扬的小鸟》游戏创建项目文件。

cd ~/project
touch flappy.py
sudo pip install pygame

在这一步中，我们将设置基本的项目结构并导入必要的库。我们还将定义一些常量并加载初始游戏资源。

from itertools import cycle
import random
import sys
import pygame
from pygame.locals import *

FPS = 30
SCREENWIDTH = 288
SCREENHEIGHT = 512
PIPEGAPSIZE = 100  ## 管道上下部分之间的间隙
BASEY = SCREENHEIGHT * 0.79
## 图像和碰撞掩码字典
IMAGES, HITMASKS = {}, {}

## 所有可能的玩家列表（翅膀扇动的 3 个位置的元组）
PLAYERS_LIST = (
    ## 红色小鸟
    (
        "data/sprites/redbird-upflap.png",
        "data/sprites/redbird-midflap.png",
        "data/sprites/redbird-downflap.png",
    ),
    ## 蓝色小鸟
    (
        "data/sprites/bluebird-upflap.png",
        "data/sprites/bluebird-midflap.png",
        "data/sprites/bluebird-downflap.png",
    ),
    ## 黄色小鸟
    (
        "data/sprites/yellowbird-upflap.png",
        "data/sprites/yellowbird-midflap.png",
        "data/sprites/yellowbird-downflap.png",
    ),
)

## 背景列表
BACKGROUNDS_LIST = (
    "data/sprites/background-day.png",
    "data/sprites/background-night.png",
)

## 管道列表
PIPES_LIST = (
    "data/sprites/pipe-green.png",
    "data/sprites/pipe-red.png",
)

• 我们导入游戏所需的必要库，包括用于创建游戏的pygame、用于生成随机元素的random、用于系统相关函数的sys以及用于按键常量的pygame.locals。
• 我们使用pygame.init()初始化 Pygame。
• 定义了诸如FPS、SCREENWIDTH、SCREENHEIGHT、PIPEGAPSIZE和BASEY等常量，以设置游戏的尺寸和速度。
• 我们创建空字典（IMAGES和HITMASKS）来存储游戏资源。
• 使用文件路径定义玩家、背景和管道资源的列表。

展示欢迎动画

在这一步中，我们将创建《飞扬的小鸟》游戏的欢迎屏幕动画。

def showWelcomeAnimation():
    """展示飞扬的小鸟的欢迎屏幕动画"""
    ## 要在屏幕上绘制的玩家索引
    playerIndex = 0
    playerIndexGen = cycle([0, 1, 2, 1])
    ## 用于在每第 5 次迭代后更改 playerIndex 的迭代器
    loopIter = 0

    playerx = int(SCREENWIDTH * 0.2)
    playery = int((SCREENHEIGHT - IMAGES["player"][0].get_height()) / 2)

    messagex = int((SCREENWIDTH - IMAGES["message"].get_width()) / 2)
    messagey = int(SCREENHEIGHT * 0.12)

    basex = 0
    ## 基地可以向左最大移动的量
    baseShift = IMAGES["base"].get_width() - IMAGES["background"].get_width()

    ## 玩家在欢迎屏幕上上下移动的共享内存值
    playerShmVals = {"val": 0, "dir": 1}

    while True:
        for event in pygame.event.get():
            if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
                pygame.quit()
                sys.exit()
            if event.type == KEYDOWN and (event.key == K_SPACE or event.key == K_UP):
                ## 发出第一次拍打声音并返回主游戏的值
                return {
                    "playery": playery + playerShmVals["val"],
                    "basex": basex,
                    "playerIndexGen": playerIndexGen,
                }

        ## 调整 playery、playerIndex、basex
        if (loopIter + 1) % 5 == 0:
            playerIndex = next(playerIndexGen)
        loopIter = (loopIter + 1) % 30
        basex = -((-basex + 4) % baseShift)
        playerShm(playerShmVals)

        ## 绘制精灵
        SCREEN.blit(IMAGES["background"], (0, 0))
        SCREEN.blit(
            IMAGES["player"][playerIndex], (playerx, playery + playerShmVals["val"])
        )
        SCREEN.blit(IMAGES["message"], (messagex, messagey))
        SCREEN.blit(IMAGES["base"], (basex, BASEY))

        pygame.display.update()
        FPSCLOCK.tick(FPS)

• 我们定义了负责显示欢迎屏幕动画的showWelcomeAnimation函数。
• 该函数为动画设置变量并处理用户输入以开始游戏。
• 它使用一个循环来更新动画帧并检查用户输入以开始游戏。
• 动画包括小鸟拍打翅膀以及屏幕上显示的一条消息。
• pygame.display.update()函数用于更新显示，FPSCLOCK.tick(FPS)控制帧率。

主游戏逻辑

在这一步中，我们将实现《飞扬的小鸟》的主游戏逻辑。

def mainGame(movementInfo):
    score = playerIndex = loopIter = 0
    playerIndexGen = movementInfo["playerIndexGen"]
    playerx, playery = int(SCREENWIDTH * 0.2), movementInfo["playery"]

    basex = movementInfo["basex"]
    baseShift = IMAGES["base"].get_width() - IMAGES["background"].get_width()

    ## 获取 2 个新管道以添加到上管道和下管道列表中
    newPipe1 = getRandomPipe()
    newPipe2 = getRandomPipe()

    ## 上管道列表
    upperPipes = [
        {"x": SCREENWIDTH + 200, "y": newPipe1[0]["y"]},
        {"x": SCREENWIDTH + 200 + (SCREENWIDTH / 2), "y": newPipe2[0]["y"]},
    ]

    ## 下管道列表
    lowerPipes = [
        {"x": SCREENWIDTH + 200, "y": newPipe1[1]["y"]},
        {"x": SCREENWIDTH + 200 + (SCREENWIDTH / 2), "y": newPipe2[1]["y"]},
    ]

    dt = FPSCLOCK.tick(FPS) / 1000
    pipeVelX = -128 * dt

    ## 玩家速度、最大速度、向下加速度、拍打时的加速度
    playerVelY = -9  ## 玩家沿 Y 轴的速度，默认与玩家拍打时相同
    playerMaxVelY = 10  ## 沿 Y 轴的最大速度，最大下降速度
    playerMinVelY = -8  ## 沿 Y 轴的最小速度，最大上升速度
    playerAccY = 1  ## 玩家向下的加速度
    playerRot = 45  ## 玩家的旋转角度
    playerVelRot = 3  ## 角速度
    playerRotThr = 20  ## 旋转阈值
    playerFlapAcc = -9  ## 玩家拍打时的速度
    playerFlapped = False  ## 玩家拍打时为 True

    while True:
        for event in pygame.event.get():
            if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
                pygame.quit()
                sys.exit()
            if event.type == KEYDOWN and (event.key == K_SPACE or event.key == K_UP):
                if playery > -2 * IMAGES["player"][0].get_height():
                    playerVelY = playerFlapAcc
                    playerFlapped = True

        ## 在此处检查碰撞
        crashTest = checkCrash(
            {"x": playerx, "y": playery, "index": playerIndex}, upperPipes, lowerPipes
        )
        if crashTest[0]:
            return {
                "y": playery,
                "groundCrash": crashTest[1],
                "basex": basex,
                "upperPipes": upperPipes,
                "lowerPipes": lowerPipes,
                "score": score,
                "playerVelY": playerVelY,
                "playerRot": playerRot,
            }

        ## 检查得分
        playerMidPos = playerx + IMAGES["player"][0].get_width() / 2
        for pipe in upperPipes:
            pipeMidPos = pipe["x"] + IMAGES["pipe"][0].get_width() / 2
            if pipeMidPos <= playerMidPos < pipeMidPos + 4:
                score += 1

        ## playerIndex 和 basex 变化
        if (loopIter + 1) % 3 == 0:
            playerIndex = next(playerIndexGen)
        loopIter = (loopIter + 1) % 30
        basex = -((-basex + 100) % baseShift)

        ## 旋转玩家
        if playerRot > -90:
            playerRot -= playerVelRot

        ## 玩家的移动
        if playerVelY < playerMaxVelY and not playerFlapped:
            playerVelY += playerAccY
        if playerFlapped:
            playerFlapped = False

            ## 更多旋转以覆盖阈值（在可见旋转中计算）
            playerRot = 45

        playerHeight = IMAGES["player"][playerIndex].get_height()
        playery += min(playerVelY, BASEY - playery - playerHeight)

        ## 将管道向左移动
        for uPipe, lPipe in zip(upperPipes, lowerPipes):
            uPipe["x"] += pipeVelX
            lPipe["x"] += pipeVelX

        ## 当第一个管道即将接触屏幕左侧时添加新管道
        if 3 > len(upperPipes) > 0 and 0 < upperPipes[0]["x"] < 5:
            newPipe = getRandomPipe()
            upperPipes.append(newPipe[0])
            lowerPipes.append(newPipe[1])

        ## 如果第一个管道超出屏幕范围，则将其移除
        if len(upperPipes) > 0 and upperPipes[0]["x"] < -IMAGES["pipe"][0].get_width():
            upperPipes.pop(0)
            lowerPipes.pop(0)

        ## 绘制精灵
        SCREEN.blit(IMAGES["background"], (0, 0))

        for uPipe, lPipe in zip(upperPipes, lowerPipes):
            SCREEN.blit(IMAGES["pipe"][0], (uPipe["x"], uPipe["y"]))
            SCREEN.blit(IMAGES["pipe"][1], (lPipe["x"], lPipe["y"]))

        SCREEN.blit(IMAGES["base"], (basex, BASEY))
        ## 显示得分，以便玩家覆盖得分
        showScore(score)

        ## 玩家旋转有一个阈值
        visibleRot = playerRotThr
        if playerRot <= playerRotThr:
            visibleRot = playerRot

        playerSurface = pygame.transform.rotate(
            IMAGES["player"][playerIndex], visibleRot
        )
        SCREEN.blit(playerSurface, (playerx, playery))

        pygame.display.update()
        FPSCLOCK.tick(FPS)

• 我们定义了mainGame函数，其中包含《飞扬的小鸟》游戏的核心逻辑。
• 该函数处理用户输入、更新游戏状态、检查碰撞并记录得分。
• 游戏循环持续运行，更新游戏的显示和逻辑。
• 通过按键事件（空格键或向上箭头）处理玩家控制。
• 该函数还检查与管道和地面的碰撞、更新得分并管理小鸟的动画。
• 游戏循环持续进行，直到玩家碰撞或退出游戏。

显示游戏结束画面

在这一步中，我们将创建玩家失败时出现的游戏结束屏幕。

def showGameOverScreen(crashInfo):
    """使玩家向下坠落并显示游戏结束画面"""
    score = crashInfo["score"]
    playerx = SCREENWIDTH * 0.2
    playery = crashInfo["y"]
    playerHeight = IMAGES["player"][0].get_height()
    playerVelY = crashInfo["playerVelY"]
    playerAccY = 2
    playerRot = crashInfo["playerRot"]
    playerVelRot = 7

    basex = crashInfo["basex"]

    upperPipes, lowerPipes = crashInfo["upperPipes"], crashInfo["lowerPipes"]

    while True:
        for event in pygame.event.get():
            if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
                pygame.quit()
                sys.exit()
            if event.type == KEYDOWN and (event.key == K_SPACE or event.key == K_UP):
                if playery + playerHeight >= BASEY - 1:
                    return

        ## 玩家 y 轴移动
        if playery + playerHeight < BASEY - 1:
            playery += min(playerVelY, BASEY - playery - playerHeight)

        ## 玩家速度变化
        if playerVelY < 15:
            playerVelY += playerAccY

        ## 仅在与管道碰撞时旋转
        if not crashInfo["groundCrash"]:
            if playerRot > -90:
                playerRot -= playerVelRot

        ## 绘制精灵
        SCREEN.blit(IMAGES["background"], (0, 0))

        for uPipe, lPipe in zip(upperPipes, lowerPipes):
            SCREEN.blit(IMAGES["pipe"][0], (uPipe["x"], uPipe["y"]))
            SCREEN.blit(IMAGES["pipe"][1], (lPipe["x"], lPipe["y"]))

        SCREEN.blit(IMAGES["base"], (basex, BASEY))
        显示得分(score)

        playerSurface = pygame.transform.rotate(IMAGES["player"][1], playerRot)
        SCREEN.blit(playerSurface, (playerx, playery))
        SCREEN.blit(IMAGES["gameover"], (50, 180))

        FPSCLOCK.tick(FPS)
        pygame.display.update()

• showGameOverScreen函数在玩家失败时显示游戏结束屏幕。
• 它显示玩家的最终得分，播放音效，并等待玩家按下空格键或向上箭头重新开始游戏。
• 动画包括小鸟坠落到地面以及屏幕上显示的游戏结束消息。

定义辅助函数

在这一步中，我们定义游戏中使用的辅助函数。

def playerShm(playerShm):
    """在 8 和 -8 之间振荡 playerShm['val'] 的值"""
    if abs(playerShm["val"]) == 8:
        playerShm["dir"] *= -1

    if playerShm["dir"] == 1:
        playerShm["val"] += 1
    else:
        playerShm["val"] -= 1


def getRandomPipe():
    """返回一个随机生成的管道"""
    ## 上下管道之间间隙的 y 坐标
    gapY = random.randrange(0, int(BASEY * 0.6 - PIPEGAPSIZE))
    gapY += int(BASEY * 0.2)
    pipeHeight = IMAGES["pipe"][0].get_height()
    pipeX = SCREENWIDTH + 10

    return [
        {"x": pipeX, "y": gapY - pipeHeight},  ## 上管道
        {"x": pipeX, "y": gapY + PIPEGAPSIZE},  ## 下管道
    ]


def showScore(score):
    """在屏幕中心显示分数"""
    scoreDigits = [int(x) for x in list(str(score))]
    totalWidth = 0  ## 要打印的所有数字的总宽度

    for digit in scoreDigits:
        totalWidth += IMAGES["numbers"][digit].get_width()

    Xoffset = (SCREENWIDTH - totalWidth) / 2

    for digit in scoreDigits:
        SCREEN.blit(IMAGES["numbers"][digit], (Xoffset, SCREENHEIGHT * 0.1))
        Xoffset += IMAGES["numbers"][digit].get_width()


def checkCrash(player, upperPipes, lowerPipes):
    """如果玩家与地面或管道碰撞，则返回 True"""
    pi = player["index"]
    player["w"] = IMAGES["player"][0].get_width()
    player["h"] = IMAGES["player"][0].get_height()

    ## 如果玩家撞到地面
    if player["y"] + player["h"] >= BASEY - 1:
        return [True, True]
    else:
        playerRect = pygame.Rect(player["x"], player["y"], player["w"], player["h"])
        pipeW = IMAGES["pipe"][0].get_width()
        pipeH = IMAGES["pipe"][0].get_height()

        for uPipe, lPipe in zip(upperPipes, lowerPipes):
            ## 上管道和下管道的矩形
            uPipeRect = pygame.Rect(uPipe["x"], uPipe["y"], pipeW, pipeH)
            lPipeRect = pygame.Rect(lPipe["x"], lPipe["y"], pipeW, pipeH)

            ## 玩家与上/下管道的碰撞掩码
            pHitMask = HITMASKS["player"][pi]
            uHitmask = HITMASKS["pipe"][0]
            lHitmask = HITMASKS["pipe"][1]

            ## 如果小鸟与上管道或下管道碰撞
            uCollide = pixelCollision(playerRect, uPipeRect, pHitMask, uHitmask)
            lCollide = pixelCollision(playerRect, lPipeRect, pHitMask, lHitmask)

            if uCollide or lCollide:
                return [True, False]

    return [False, False]


def pixelCollision(rect1, rect2, hitmask1, hitmask2):
    """检查两个物体是否碰撞，而不仅仅是它们的矩形"""
    rect = rect1.clip(rect2)

    if rect.width == 0 or rect.height == 0:
        return False

    x1, y1 = rect.x - rect1.x, rect.y - rect1.y
    x2, y2 = rect.x - rect2.x, rect.y - rect2.y

    for x in range(rect.width):
        for y in range(rect.height):
            if hitmask1[x1 + x][y1 + y] and hitmask2[x2 + x][y2 + y]:
                return True
    return False


def getHitmask(image):
    """使用图像的透明度返回一个碰撞掩码"""
    mask = []
    for x in range(image.get_width()):
        mask.append([])
        for y in range(image.get_height()):
            mask[x].append(bool(image.get_at((x, y))[3]))
    return mask

• playerShm函数在 8 和 -8 之间振荡playerShm["val"]的值。这用于在欢迎屏幕上使小鸟上下移动。
• getRandomPipe函数返回一个随机生成的管道。它在上管道和下管道之间生成一个随机间隙。
• showScore函数在屏幕中心显示分数。它使用IMAGES["numbers"]列表来显示分数。
• checkCrash函数如果玩家与地面或管道碰撞，则返回True。它使用pixelCollision函数来检查碰撞。
• pixelCollision函数检查两个物体是否碰撞，而不仅仅是它们的矩形。它使用getHitmask函数来获取玩家和管道的碰撞掩码。
• getHitmask函数使用图像的透明度返回一个碰撞掩码。它使用image.get_at函数获取图像中每个像素的透明度值。

主函数

在这一步中，我们定义主函数，该函数初始化游戏并启动游戏循环。

def main():
    global SCREEN, FPSCLOCK
    pygame.init()
    FPSCLOCK = pygame.time.Clock()
    SCREEN = pygame.display.set_mode((SCREENWIDTH, SCREENHEIGHT))
    pygame.display.set_caption("Flappy Bird")

    ## 用于显示分数的数字精灵
    IMAGES["numbers"] = (
        pygame.image.load("data/sprites/0.png").convert_alpha(),
        pygame.image.load("data/sprites/1.png").convert_alpha(),
        pygame.image.load("data/sprites/2.png").convert_alpha(),
        pygame.image.load("data/sprites/3.png").convert_alpha(),
        pygame.image.load("data/sprites/4.png").convert_alpha(),
        pygame.image.load("data/sprites/5.png").convert_alpha(),
        pygame.image.load("data/sprites/6.png").convert_alpha(),
        pygame.image.load("data/sprites/7.png").convert_alpha(),
        pygame.image.load("data/sprites/8.png").convert_alpha(),
        pygame.image.load("data/sprites/9.png").convert_alpha(),
    )

    ## 游戏结束精灵
    IMAGES["gameover"] = pygame.image.load("data/sprites/gameover.png").convert_alpha()
    ## 欢迎屏幕的消息精灵
    IMAGES["message"] = pygame.image.load("data/sprites/message.png").convert_alpha()
    ## 基地（地面）精灵
    IMAGES["base"] = pygame.image.load("data/sprites/base.png").convert_alpha()

    while True:
        ## 选择随机的背景精灵
        randBg = random.randint(0, len(BACKGROUNDS_LIST) - 1)
        IMAGES["background"] = pygame.image.load(BACKGROUNDS_LIST[randBg]).convert()

        ## 选择随机的玩家精灵
        randPlayer = random.randint(0, len(PLAYERS_LIST) - 1)
        IMAGES["player"] = (
            pygame.image.load(PLAYERS_LIST[randPlayer][0]).convert_alpha(),
            pygame.image.load(PLAYERS_LIST[randPlayer][1]).convert_alpha(),
            pygame.image.load(PLAYERS_LIST[randPlayer][2]).convert_alpha(),
        )

        ## 选择随机的管道精灵
        pipeindex = random.randint(0, len(PIPES_LIST) - 1)
        IMAGES["pipe"] = (
            pygame.transform.flip(
                pygame.image.load(PIPES_LIST[pipeindex]).convert_alpha(), False, True
            ),
            pygame.image.load(PIPES_LIST[pipeindex]).convert_alpha(),
        )

        ## 管道的碰撞掩码
        HITMASKS["pipe"] = (
            getHitmask(IMAGES["pipe"][0]),
            getHitmask(IMAGES["pipe"][1]),
        )

        ## 玩家的碰撞掩码
        HITMASKS["player"] = (
            getHitmask(IMAGES["player"][0]),
            getHitmask(IMAGES["player"][1]),
            getHitmask(IMAGES["player"][2]),
        )

        movementInfo = showWelcomeAnimation()
        crashInfo = mainGame(movementInfo)
        showGameOverScreen(crashInfo)

• main函数初始化游戏，设置显示，并启动游戏循环。
• 它加载游戏资源，包括图像，并随机选择背景、玩家和管道精灵。
• 游戏循环处理欢迎动画、主游戏和游戏结束屏幕。
• 游戏持续循环，直到玩家退出游戏或关闭窗口。

运行游戏

在这一步中，我们将运行《飞扬的小鸟》游戏。

if __name__ == "__main__":
    main()

• __name__ == "__main__" 条件用于检查当前模块是被直接运行还是被其他模块导入。
• 如果当前模块是被直接运行，则调用 main 函数来启动游戏。

完成所有步骤后，你可以使用以下命令运行《飞扬的小鸟》游戏：

cd ~/project
python flappy.py

总结

在这个项目中，我们将《飞扬的小鸟》游戏代码拆分为多个步骤，并对每个步骤都进行了解释。你已经学会了如何创建一个基本的游戏结构、处理玩家输入、更新游戏状态、检查碰撞以及显示游戏屏幕。现在你可以使用提供的代码来运行和玩《飞扬的小鸟》游戏了。享受你的游戏开发之旅吧！