个人笔记——通过飞机大战学习Pygame

背景

游戏的初始化和退出

面向对象编程基本概念

要使用pygame提供的所有功能之前，需要调用init方法，在游戏结束前需要调用一下quit方法

方法	说明
pygame.init()	导入并初始化所有的pygame模块，使用其他模块之前，必须使用init方法
pygame.quit()	卸载所有pygame模块，在游戏结束之前调用

坐标系

原点：左上角(0, 0)
x轴向右，y轴向下
所有课件元素以矩形区域来描述位置，四要素：(x, y)(width, height)
pygame专门提供了一个类pygame.Rect用于描述矩形区域

Rect(x, y, width, height) -> Rect  # 右边代表返回值

注：pygame.Rect是一个比较特殊的类，内部只是封装了一些数字计算，不执行pygame.init()方法同样能够直接使用
例：

>>hero_rect = pygame.Rect(100, 500, 120, 150)

print("英雄的原点 %d %d" % (hero_rect.x, hero_rect.y))
print("英雄的尺寸 %d %d" % (hero_rect.width, hero_rect.height))
print("%d %d" % hero_rect.size)  # size方法包含了width和height，即对象的尺寸
>英雄的原点 100 500
英雄的尺寸 120 150
120 150

创建游戏主窗口

pygame专门提供了一个模块pygame.display用于创建、管理游戏窗口

方法	说明
pygame.display.set_mode()	初始化游戏显示窗口
pygame.display.update()	刷新屏幕显示内容

set_mode(resolution=(0, 0), flags=0, depth=0) -> Surface

resolution制定屏幕的宽和高，默认创建的窗口大小和屏幕大小一致
flags参数指定屏幕的附加选项，例如是否全屏等等，默认不需要传递
depth参数表示颜色的位数，默认自动匹配
set_mode返回的Surface可以理解为游戏的屏幕，游戏元素都需要被绘制到游戏屏幕上
注：必须使用变量记录set_mode方法的返回结果

screen = pygame.display.set_mode((480, 700))

绘制图像

使用图像文件的第一步就是将图像加载到内存
要在屏幕上看到某一个图像的内容，需要按照三个步骤：
1.使用pygame.image.load()加载图像数据
2.使用游戏屏幕对象，调用blit方法将图像绘制到指定位置
3.调用pygame.display.update()方法更新整个屏幕的显示

关于update()

可以在screen对象完成所有blit方法之后，统一调用display.update方法
使用display.set_mode()创建的screen对象是一个内存中的屏幕数据对象，可以理解成油画的画布
screen.blit方法可以在画布上绘制图像，图像可以重叠
display.update()会将最终结果绘制在屏幕上，这样可以提高屏幕绘制效率，增加游戏流畅度

游戏循环

游戏时钟

pygame提供了一个类pygame.time.Clock可以非常方便的设置屏幕绘制速度即刷新帧率
使用步骤：
1.在游戏初始化创建一个时钟对象
2.在游戏循环中让时钟对象调用tick(帧率)方法
tick方法会根据上次被调用的时间，自动设置游戏循环中的延时

飞机移动

在对飞机的坐标进行操作后（即hero_rect.x， hero_rect.y），需要用update()更新图像，但需要注意每次调用update()都需要把所有的游戏图像都重新绘制一遍，最先绘制背景将之前的图像覆盖，不然会留下残影

监听事件

pygame中通过pygame.event.get()可以获得用户当前所做动作的事件列表

精灵和精灵组

精灵：pygame.sprite.Sprite用来存储图像数据image和位置rect的对象，update(*args)可以更新精灵位置，kill()可以从所有组中删除
精灵组：即精灵可以添加入组中，init(self, *精灵)，add(*sprite)可以向组中添加精灵，sprites()可以返回所有精灵列表，update()可以让组中所有精灵使用update()，draw(Surface)可以将组中所有精灵的image绘制到Surface的rect位置

定时器与敌机

在pygame中可以使用pygame.time.set_timer()来添加定时器
定时器就是每隔一段时间去执行一些动作

set_timer(eventid, milliseconds) -> None

set_timer可以创建一个事件，可以在游戏循环的事件监听方法中捕获到该事件
第1个参数eventid需要基于常量pygame.USEREVENT来指定，USEREVENT是一个整数，再增加的事件可以使用USEREVENT+1指定，以此类推
第2个参数milliseconds是事件触发间隔的毫秒值

定时器事件的监听

通过pygame.event.get()可以获取当前时刻所有的事件列表
遍历列表判断event.type是否等于eventid，如果相等，表示定时器事件发生

使用方法

1.定义定时器常量——eventid
2.在初始化方法中，调用set_timer方法设置定时器事件
3.在游戏循环中监听

rect.bottom

为了避免敌机突兀出现，可以设置敌机的初始位置，即rect.y，理论上应设置为图片高度的负值，不过可以直接使用bottom方法，bottom=y+height，另bottom=0则敌机就会被置于屏幕上方，逐渐进入屏幕

slef.rect.bottom = 0

销毁敌机的实现

用内置方法__del__来实现

英雄飞机

键盘捕获

在pygame中针对键盘按键的捕获，有两种方式
1.判断event.type == pygame.KEYDOWN

if event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT:
	print("向右移动")

只能检测到一次按键，持续按键也只输出一次
2.首先使用pygame.key.get_pressed()返回所有按键元组，通过键盘常量，判断元组中某一个键是否被按下——如果按下，对应数值为1。可以持续按键输出

keys_pressed = pygame.key.get_pressed()
if keys_pressed[pygame.K_right]:
	print("向右移动")

子弹

使用定时器来发射子弹，主要注意子弹的初始位置

碰撞检测

pygame提供了两个碰撞检测方法
1.pygame.sprite.groupcollide()用于检测两个精灵组中所有的精灵的碰撞

groupcollide(group1, group2, dokill1, dokill2, collided=None) -> Sprite_dict

如果将dokill设置为True， 则发生碰撞的精灵将被自动移除
collided参数是用于计算碰撞的回调函数，如果没有指定，则每个精灵都必须有一个rect属性

2.pygame.sprite.spritecollide()用于判断某个精灵和指定精灵组中的精灵的碰撞

spritecollide(sprite, group, dokill, collided=None) -> Sprite_list

如果将dokill设置为True，则指定精灵组中发生碰撞的精灵将被自动移除， 返回精灵组中和精灵发生碰撞的精灵列表

完整代码

主程序

import pygame
from plane_fight_sprite import *

# 屏幕大小的常量


class PlaneGame(object):
    def __init__(self):
        print("游戏初始化")

        # 创建游戏窗口
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)

        # 创建游戏时钟
        self.clock = pygame.time.Clock()

        # 调用私有方法创建精灵/精灵组
        self.__creat_sprite()

        # 设置定时器事件
        pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)
        pygame.time.set_timer(HERO_FIRE_EVENT, 500)

    def __creat_sprite(self):
        # 创建背景精灵和精灵组
        bg1 = Background()
        bg2 = Background(is_alt=True)

        self.back_group = pygame.sprite.Group(bg1, bg2)

        # 创建敌机的精灵组，不用在这里创建敌机，因为敌机是定时出现的，在事件监听时发生
        self.enemy_group = pygame.sprite.Group()

        # 创建英雄精灵和精灵组
        self.hero = Hero()
        self.hero_group = pygame.sprite.Group(self.hero)

    def start_game(self):
        print("游戏开始...")
        while True:
            # 设置刷新帧率
            self.clock.tick(FRAME_PRE_SET)
            # 事件监听
            self.__event_handler()
            # 碰撞检测
            self.__check_collide()
            # 更新/绘制精灵组
            self.__update_sprites()
            # 更新显示
            pygame.display.update()

    def __event_handler(self):
        for event in pygame.event.get():

            # 判断是否退出游戏
            if event.type == pygame.QUIT:
                PlaneGame.__game_over()

            elif event.type == CREATE_ENEMY_EVENT:
                # 创建敌机精灵
                enemy = Enemy()
                # 将敌机精灵添加到敌机精灵组
                self.enemy_group.add(enemy)

            # elif event.type == HERO_FIRE_EVENT:
            #     self.hero.fire()

            keys_pressed = pygame.key.get_pressed()
            if keys_pressed[pygame.K_j] and event.type == HERO_FIRE_EVENT:
                self.hero.fire()

            if keys_pressed[pygame.K_RIGHT] or keys_pressed[pygame.K_d]:
                self.hero.speed = 2
                self.hero.speedy = 0
                # print("向右移动...")
            elif keys_pressed[pygame.K_LEFT] or keys_pressed[pygame.K_a]:
                self.hero.speed = -2
                self.hero.speedy = 0
            elif keys_pressed[pygame.K_UP]or keys_pressed[pygame.K_w]:
                self.hero.speed = 0
                self.hero.speedy = -2
            elif keys_pressed[pygame.K_DOWN]or keys_pressed[pygame.K_s]:
                self.hero.speed = 0
                self.hero.speedy = 2
            else:
                self.hero.speed = 0
                self.hero.speedy = 0

    def __check_collide(self):
        # 子弹摧毁敌机
        pygame.sprite.groupcollide(self.hero.bullets, self.enemy_group, True, True)


        # 敌机撞毁英雄
        enemies = pygame.sprite.spritecollide(self.hero, self.enemy_group, True)
        if enemies:
            self.hero.kill()
            PlaneGame.__game_over()

    def __update_sprites(self):
        self.back_group.update()
        self.back_group.draw(self.screen)

        self.enemy_group.update()
        self.enemy_group.draw(self.screen)

        self.hero_group.update()
        self.hero_group.draw(self.screen)

        self.hero.bullets.update()
        self.hero.bullets.draw(self.screen)

    @staticmethod
    def __game_over():
        print("游戏结束")
        pygame.quit()
        exit()


if __name__ == '__main__':
    # 创建游戏对象
    game = PlaneGame()
    # 启动游戏
    game.start_game()

功能程序

import pygame
import random


SCREEN_RECT = pygame.Rect(0, 0, 480, 700)
FRAME_PRE_SET = 60
# 创建敌机定时器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
# 英雄发射子弹
HERO_FIRE_EVENT = pygame.USEREVENT + 1


class GameSprite(pygame.sprite.Sprite):
    def __init__(self, image_name, speed=1):
        super().__init__()
        self.image = pygame.image.load("./images/%s.png" % image_name)
        self.rect = self.image.get_rect()
        self.speed = speed

    def update(self, *args):
        self.rect.y += self.speed


class Background(GameSprite):
    def __init__(self, is_alt=False):
        super().__init__("background")
        # 判断是否是交替图像
        if is_alt:
            self.rect.y = -self.rect.height

    def update(self, *args):
        super().update()
        if self.rect.y >= SCREEN_RECT.height:
            self.rect.y = -self.rect.height


class Enemy(GameSprite):
    def __init__(self):
        super().__init__("enemy1", speed=random.randint(1, 3))
        # 设置敌机初始y值在屏幕上方 bottom = y + height = 0 即 y = -height
        self.rect.bottom = 0
        # 设置敌机初始x范围
        self.rect.x = random.randint(0, SCREEN_RECT.width-self.rect.width)

    def update(self, *args):
        super().update()
        if self.rect.y >= SCREEN_RECT.height:
            # print("飞出屏幕，需要从精灵组中删除")
            self.kill()

    def __del__(self):
        # print("敌机挂了 %s" % self.rect)
        pass


class Hero(GameSprite):
    def __init__(self):
        super().__init__("me1", speed=0)
        self.rect.centerx = SCREEN_RECT.centerx
        self.rect.bottom = SCREEN_RECT.bottom - 120
        self.speedy = 0

        # 创建子弹精灵组
        self.bullets = pygame.sprite.Group()

    def update(self, *args):
        self.rect.x += self.speed
        self.rect.y += self.speedy

        # 控制英雄不离开屏幕
        if self.rect.x < 0:
            self.rect.x = 0
        elif self.rect.right > SCREEN_RECT.width:
            self.rect.right = SCREEN_RECT.width
        elif self.rect.y < 0:
            self.rect.y = 0
        elif self.rect.bottom > SCREEN_RECT.height:
            self.rect.bottom = SCREEN_RECT.height

    def fire(self):
        for i in range(3):
            # 创建子弹精灵
            bullet = Bullet()
            # 设置初始位置
            bullet.rect.bottom = self.rect.y - 20 * i
            bullet.rect.centerx = self.rect.centerx
            # 将精灵添加到精灵组
            self.bullets.add(bullet)
            # print("发射子弹")


class Bullet(GameSprite):
    def __init__(self):
        super().__init__("bullet1", speed=-2)

    def update(self, *args):
        super().update()
        if self.rect.bottom < 0:
            self.kill()

    def __del__(self):
        pas