第四阶段：飞机大战项目实战

1.4项目飞机大战

1.4.1项目准备

1.4.1.1确定模块pygame是否安装成功

1. 安装pygame模块时要注意python的版本是否有对应的pygame版本

   • https://pypi.org/project/pygame/#files查看对应的python版本是否有对应的pygame版本(cp37就表示pygame支持的python版本为python3.7)，如果有就可以进行后续的安装
   • 如果当前python版本没有对应的pygame版本(比如当前写文档的时间看python3.8版本的Mac版本就没有对应的pygame版本，也就是说，Mac电脑如果安装的python版本是3.8的，那么就无法安装pygame，此时就必须更改python的版本)

2. 安装pygame模块

   $ sudo pip3 install pygame
   

3. 验证是否安装成功(安装成功会有自带的游戏界面显示)

   $ python3 -m pygame.examples.aliens
   

1.4.1.2项目准备

1. 新建飞机大战项目
2. 新建一个dt_01_pygame入门.py
3. 导入游戏素材图片

1.4.2游戏窗口和绘制图像

1.4.2.1游戏窗口

1.4.2.1.1游戏的初始化和退出

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

   方法	说明
   pygame.init()	导入并初始化所有的pygame模块，使用其它模块之前必须先调用init方法
   pygame.quit()	卸载所有的pygame模块，在游戏结束之前调用(及时释放内存中的空间)

1.4.2.1.2pygame.Rect描述矩形区域

1. 在游戏中，所有可见元素都是以矩形区域来描述位置的，要描述一个矩形区域有四个要素(x, y)(width, height)，分别表示横坐标、纵坐标、矩形的宽度、矩形的高度

2. pygame专门提供了一个类pygame.Rect用于描述矩形区域

   Rect(x, y, width, height)  # 创建对象 
   

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

   import pygame
   test = pygame.Rect(100, 200, 10, 20)
   print("对象的坐标是:%d %d" % (test.x, test.y))
   print("对象的大小是:%d %d" % (test.size))  # size属性返回的是一个元祖，包含两个内容：widht和height
   

1.4.2.1.3创建游戏窗口和游戏循环

1. 创建游戏主窗口和游戏循环

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

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

   • set_mode()方法

     set_mode(resolution=(0,0), flags=0, depth=0) ->Surface
     # 三个参数是缺省参数，可以不传值，set_mode()方法返回的是一个窗口
     # resolution是一个元祖，两个数字分别表示窗口是宽度和高度；flays参数用来指定窗口的附加选项，例如是否全屏；depth参数表示颜色的位数，默认自动匹配
     # set_mode()方法的返回值必须要有变量进行记录，因为后期所有的操作都是基于这个返回结果的
     

   • 游戏循环防止窗口一闪后立刻退出

   • 代码实例：

     import pygame
     pygame.init()
     main_windows = pygame.display.set_mode((100,100))  # 这里(100,100)之前不能写参数resolution，直接写元祖表示窗口的宽度和高度就好
     # 无限循环防止窗口一闪而过
     while True:
          pass
     pygame.quit()
     

1.4.2.2绘制图像

1.4.2.2.1绘制图像的三个步骤

1. 将图像加载到内存

   • 使用pygame.image.load()加载图像的数据

2. 使用屏幕对象，调用blit方法将加载的图像绘制到指定的位置

3. 调用pygame.display.update()方法更新屏幕的显示

4. 透明图像：对于一些图像周围有虚线就表示这部分图片是透明的，也就是说当将这类图片插入到背景中时原背景会覆盖虚线部分

5. 可以在所有的图片都绘制完毕后统一更新屏幕(即只需要调用一次update方法)

6. 在游戏中每一次调用update()方法产生的效果叫做帧，一般在电脑上每秒绘制60次(也就是每秒调用60次update方法)就能够达到连续、高品质的动画效果

7. 代码演练

   import pygame
   pygame.init()
   screen = pygame.display.set_mode((480,700))
   # 绘制背景图像
   bg = pygame.image.load("./images/background.png")
   screen.blit(bg, (0, 0))
   # 绘制英雄飞机图像
   hero = pygame.image.load("./images/me1.png")
   screen.blit(hero, (200, 500))
   pygame.display.update()  # update方法只需调用一次
   pygame.event.get()  # 最新版的pygame需要添加此行代码才会更新图片，否则图片不会被插入显示
   # 上一行代码不需要每次添加图片都写一次，只需要在最后一个图片插入后写一次即可
   # 无限循环防止窗口一闪而过
   while True:
        pass
   
   pygame.quit()
   

1.4.3游戏循环和键盘事件

1.4.3.1游戏循环

1.4.3.1.1相关概念介绍

1. 游戏循环意味着游戏的正式开始
2. 在游戏开发中通常将游戏分为两个部分：游戏初始化(设置游戏窗口、绘制图像初始位置、设置游戏时钟)和游戏循环(设置刷新频率、检测用户交互、更新所有图像的位置、更新屏幕显示)

1.4.3.1.2利用时钟设置游戏循环的刷新帧率

1. 创建时钟对象：clock = pygame.time.Clock()

2. 调用tick方法设置游戏循环的帧率：clock.tick(60)

3. 代码实例

   import pygame
   pygame.init()
   screen = pygame.display.set_mode((480,700))
   # 绘制背景图像
   bg = pygame.image.load("./images/background.png")
   screen.blit(bg, (0, 0))
   # 绘制英雄飞机图像
   hero = pygame.image.load("./images/me1.png")
   screen.blit(hero, (200, 500))
   pygame.display.update()  # update方法只需调用一次
   pygame.event.get()  # 最新版的pygame需要添加此行代码才会更新图片，否则图片不会被插入显示
   # 上一行代码不需要每次添加图片都写一次，只需要在最后一个图片插入后写一次即可
   # 无限循环防止窗口一闪而过
   clock = pygame.time.Clock()  # 创建时钟对象
   i = 0
   while True:
        clock.tick(60)  # 调用tick方法设置循环的执行频率(括号内的数字意味着循环一秒执行多少次)
        print(i)
        i += 1
   
   pygame.quit()
   

1.4.3.1.3英雄动画效果实现

1. 在游戏循环中每一次调用update方法之前都需要重新绘制游戏图像，首先要重新绘制背景图像

   import pygame
   pygame.init()
   screen = pygame.display.set_mode((480,700))
   # 绘制背景图像
   bg = pygame.image.load("./images/background.png")
   screen.blit(bg, (0, 0))
   # 绘制英雄飞机图像
   hero = pygame.image.load("./images/me1.png")
   screen.blit(hero, (200, 500))
   pygame.display.update()  # update方法只需调用一次
   pygame.event.get()  # 最新版的pygame需要添加此行代码才会更新图片，否则图片不会被插入显示
   # 上一行代码不需要每次添加图片都写一次，只需要在最后一个图片插入后写一次即可
   # 无限循环防止窗口一闪而过
   # 记录英雄的初始位置
   hero_rect = pygame.Rect(200, 500, 100, 126)
   clock = pygame.time.Clock()  # 创建时钟对象
   while True:
        clock.tick(5)  # 调用tick方法设置循环的执行频率(括号内的数字意味着循环一秒执行多少次)
        if hero_rect.bottom > 0:  # 判断是否到达背景顶部，这里bottom = y + height
            hero_rect.y -= 50
            # 在游戏循环中每一次调用update方法之前都需要重新绘制游戏图像，首先要重新绘制背景图像
            screen.blit(bg,(0, 0))  # 重新绘制背景
            screen.blit(hero, hero_rect)  # 这里可以直接写对象
            pygame.display.update()
            pygame.event.get()
        else:  # 实现英雄的循环出现
            hero_rect.y = 700  # 让英雄出现在背景底部
   pygame.quit()
   

1.4.3.2事件监听

1.4.3.2.1基本概念和相关方法

1. 事件event：

   • 就是游戏启动后，用户针对有戏所做的操作
   • 例如：点击关闭按钮，点击鼠标，按下键盘

2. 监听：

   • 在游戏循环中判断用户的具体的操作

3. 代码实现

   • 在python中通过pygame.event.get()可以获取用户当前所做的事件列表，一个用户一个时间内可以做很多事情

   • 代码实现

     import pygame
     pygame.init()
     screen = pygame.display.set_mode((480,700))
     # 绘制背景图像
     bg = pygame.image.load("./images/background.png")
     screen.blit(bg, (0, 0))
     # 绘制英雄飞机图像
     hero = pygame.image.load("./images/me1.png")
     screen.blit(hero, (200, 500))
     pygame.display.update()  # update方法只需调用一次
     pygame.event.get()  # 最新版的pygame需要添加此行代码才会更新图片，否则图片不会被插入显示
     # 上一行代码不需要每次添加图片都写一次，只需要在最后一个图片插入后写一次即可
     # 无限循环防止窗口一闪而过
     # 记录英雄的初始位置
     hero_rect = pygame.Rect(200, 500, 100, 126)
     clock = pygame.time.Clock()  # 创建时钟对象
     while True:
          clock.tick(5)  # 调用tick方法设置循环的执行频率(括号内的数字意味着循环一秒执行多少次)
          # 捕获事件
          event_list = pygame.event.get()  # 返回的是一个列表
          if len(event_list) > 0:  # 判断用户是否作出操作
              print(event_list)
          if hero_rect.bottom > 0:  # 判断是否到达背景顶部，这里bottom = y + height
              hero_rect.y -= 50
              # 在游戏循环中每一次调用update方法之前都需要重新绘制游戏图像，首先要重新绘制背景图像
              screen.blit(bg,(0, 0))  # 重新绘制背景
              screen.blit(hero, hero_rect)  # 这里可以直接写对象
              pygame.display.update()
              pygame.event.get()
          else:  # 实现英雄的循环出现
              hero_rect.y = 700  # 让英雄出现在背景底部
     pygame.quit()
     

1.4.3.2.2监听退出事件并且退出游戏

import pygame
pygame.init()
screen = pygame.display.set_mode((480,700))
# 绘制背景图像
bg = pygame.image.load("./images/background.png")
screen.blit(bg, (0, 0))
# 绘制英雄飞机图像
hero = pygame.image.load("./images/me1.png")
screen.blit(hero, (200, 500))
pygame.display.update()  # update方法只需调用一次
pygame.event.get()  # 最新版的pygame需要添加此行代码才会更新图片，否则图片不会被插入显示
# 上一行代码不需要每次添加图片都写一次，只需要在最后一个图片插入后写一次即可
# 无限循环防止窗口一闪而过
# 记录英雄的初始位置
hero_rect = pygame.Rect(200, 500, 100, 126)
clock = pygame.time.Clock()  # 创建时钟对象
while True:
     clock.tick(5)  # 调用tick方法设置循环的执行频率(括号内的数字意味着循环一秒执行多少次)
     for event in pygame.event.get():  # 遍历用户的操作(每次调用该方法列表中存储的是当前的操作，不会保存之前的操作)
         if event.type == pygame.QUIT:  # 判断用户的操作是否为关闭操作
             print("退出游戏")
             pygame.quit()  # 卸载所有模块
             exit()  # 终止当前正在运行的程序
     if hero_rect.bottom > 0:  # 判断是否到达背景顶部，这里bottom = y + height
         hero_rect.y -= 50
         # 在游戏循环中每一次调用update方法之前都需要重新绘制游戏图像，首先要重新绘制背景图像
         screen.blit(bg,(0, 0))  # 重新绘制背景
         screen.blit(hero, hero_rect)  # 这里可以直接写对象
         pygame.display.update()
         pygame.event.get()
     else:  # 实现英雄的循环出现
         hero_rect.y = 700  # 让英雄出现在背景底部

1.4.4精灵和精灵组

1.4.4.1基本概念

1. 为了简化开发步骤，pygame提供了两个类：pygame.sprite.Sprite和pygame.sprite.Group，其中pygame.sprite.Sprite存储了图像数据image和位置rect的对象

2. 现在，一个游戏分为两个部分：游戏初始化(创建精灵、创建精灵组)和游戏循环(精灵组.update()，精灵组.draw(screen)，pygame.display.update())

3. 精灵和精灵组

   精灵(需要派生子类)
   image：记录图像数据；rect：记录在屏幕上的位置
   update(*args)：更新精灵位置；kill()：从所有组中删除

   精灵组
   _init_(self, *精灵)：add(*sprites)：向组中增加精灵；sprites()：返回所有精灵列表；update(*args)：让组中所有精灵调用update方法；draw(Surface)：将组中所有精灵的image绘制到Surface的rect位置

1.4.4.2派生精灵子类

1. 代码实现

   import pygame
   # 创建精灵子类
   class GameSprite(pygame.sprite.Sprite):
       """飞机大战游戏精灵"""
       def __init__(self, image_name, speed = 1):
           # 调用父类的初始化方法
           super().__init__()
           # 定义对象的属性
           self.image = pygame.image.load(image_name)  # 加载图片到内存
           # 下一行代码的image表示属性，get_rect()方法返回的图像宽和图像高就是image的宽和高
           self.rect = self.image.get_rect()  # get_rect()方法可以返回pygame.Rect(0,0,图像宽,图像高)的对象
           self.speed = speed
       def update(self):
           # 在屏幕的垂直方向上移动
           self.rect.y += self.speed
   
   print(GameSprite.__mro__)
   

2. 说明：如果一个类的父类不是object(这里的父类事名义上的父类)，在重写父类的__init__方法时，要使用super()主动调用父类的__init__方法，否则子类将无法使用父类__init__中的方法和属性

1.4.4.3设置敌机精灵组

1. 精灵类

   import pygame
   # 创建精灵子类
   class GameSprite(pygame.sprite.Sprite):
       """飞机大战游戏精灵"""
       def __init__(self, image_name, speed = 1):
           # 调用父类的初始化方法
           super().__init__()
           # 定义对象的属性
           self.image = pygame.image.load(image_name)  # 加载图片到内存
           # 下一行代码的image表示属性，get_rect()方法返回的图像宽和图像高就是image的宽和高
           self.rect = self.image.get_rect()  # get_rect()方法可以返回pygame.Rect(0,0,图像宽,图像高)的对象
           self.speed = speed
       def update(self):
           # 在屏幕的垂直方向上移动
           self.rect.y += self.speed
   

2. 实现代码

   import pygame
   from test_01 import GameSprite
   pygame.init()
   screen = pygame.display.set_mode((480,700))
   # 绘制背景图像
   bg = pygame.image.load("./images/background.png")
   screen.blit(bg, (0, 0))
   # 绘制英雄飞机图像
   hero = pygame.image.load("./images/me1.png")
   screen.blit(hero, (200, 500))
   pygame.display.update()  # update方法只需调用一次
   pygame.event.get()  # 最新版的pygame需要添加此行代码才会更新图片，否则图片不会被插入显示
   # 上一行代码不需要每次添加图片都写一次，只需要在最后一个图片插入后写一次即可
   # 无限循环防止窗口一闪而过
   # 记录英雄的初始位置
   hero_rect = pygame.Rect(200, 500, 100, 126)
   clock = pygame.time.Clock()  # 创建时钟对象
   # 创建敌机的精灵
   enemy_1 = GameSprite(image_name = "./images/enemy1.png", speed = 2)
   enemy_2 = GameSprite("./images/enemy1.png")
   # 创建敌机的精灵组
   enemy_group = pygame.sprite.Group(enemy_1, enemy_2)  # 初始化方法中的当前参数可以接受一个元祖
   
   
   
   while True:
        for event in pygame.event.get():  # 遍历用户的操作(每次调用该方法列表中存储的是当前的操作，不会保存之前的操作)
            if event.type == pygame.QUIT:  # 判断用户的操作是否为关闭操作
                print("退出游戏")
                pygame.quit()  # 卸载所有模块
                exit()  # 终止当前正在运行的程序
        if hero_rect.bottom > 0:  # 判断是否到达背景顶部，这里bottom = y + height
            hero_rect.y -= 3
            # 在游戏循环中每一次调用update方法之前都需要重新绘制游戏图像，首先要重新绘制背景图像
            screen.blit(bg,(0, 0))  # 重新绘制背景
            screen.blit(hero, hero_rect)  # 这里可以直接写对象
        else:  # 实现英雄的循环出现
            hero_rect.y = 700  # 让英雄出现在背景底部
        clock.tick(60)  # 调用tick方法设置循环的执行频率(括号内的数字意味着循环一秒执行多少次)
        # 让精灵组中的每个精灵更新位置(调用update方法)
        enemy_group.update()
        # 让精灵组中的每个精灵都绘制到屏幕上
        enemy_group.draw(screen)
        pygame.display.update()
   

1.4.5框架搭建

1.4.5.1明确类的相关设计

1. 设置一个主程序plan_main用以实现游戏；设置一个程序plan_sprites实现其它功能

   • plan_main

     plan_main
     封装主游戏类
     创建游戏对象
     启动游戏

   • plan_sprites

     plan_sprites
     封装游戏中所有需要的精灵子类
     提供游戏的相关工具

2. 设计一个主游戏类PlanGame类，实现以下功能

   PlanGame
   screen;clock;精灵组或精灵
   _init_(self):游戏初始化;__create_sptites(self):创建精灵;start_game(self):游戏循环;__event_handler(self):事件监听;__check_collide(self):碰撞检测;__update_sprites(self):更新精灵组;__game_over():游戏结束

3. 游戏初始化方法__init__()功能实现

   游戏初始化
   设置游戏窗口
   创建游戏时钟
   创建精灵、精灵组

4. 游戏循环方法start_game()功能实现

   游戏循环
   设置刷新频率
   事件监听
   碰撞检测
   更新/绘制精灵组
   更新屏幕显示

1.4.5.2常量的定义

1. 在python中没有严格意义上的常量，只是通过命名的约束(通常所有字母都是大写就看作为常量)，常量的单词之间用下划线连接；在实际开发中为防止某一个值的需求一直变化导致需要修改程序中所有的原先初值，可以将这个值设置为一个常量，当需求变化时只需要修改改常量的值即可而不需要修改原先所有的值

1.4.6背景图像

1.4.6.1实现背景图像的交替滚动

1. 使用两张图像来实现背景图像的交替滚动

2. 设置背景类Background来继承GameSprite类，同时拓展背景类来实现背景图像的交替滚动实现的功能(重写init方法时新增一个参数is_alt用来判断图像是否时交替图像)

   Background
   _init_(self, is_alt):update(self)

1.4.7敌人飞机

1.4.8英雄飞机

1.4.8.1针对键盘按键的捕获

1. 方式一：判断event.type == pygame.KEYDOWN

   实例：
   if event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT:
   	print("向右移动")
   # event不是模块而是获取到的监听事件，event.key == pygame.K_RIGHT是用来判断用户的按键是否是右键，这种方法如果一直按键不放是只会识别为只按下了一次键而不会识别为连续按下多次键
   

2. 方式二：首先使用pygame.key.get_pressed()返回所有按键元祖，然后通过键盘常量，判断元祖中某一个键是否被按下(如果被按下，对应数值为1)

   实例：
   keys_pressed = pygame.key.get_pressed()
   if keys_pressed[pygame.K_RIGHT]: # 这里的pygame.K_RIGHT是元祖的索引
   	print("向右移动")
   # 这种方法如果一直按键不放会识别为连续按下多次键
   

1.4.9发射子弹以及碰撞检测

1.4.9.1定时器使用套路

1. 第一步：定义计时器常量eventid(一般用USEREVENT来表示第一个事件，后面如果要增加事件就+1即可)

2. 第二步：在初始化方法中调用set_timer方法设置定时器事件

3. 第三步：在游戏循环中监听定时器事件

4. 代码实例：

   # 第一步：定义计时器常量
   CREATE_ENEMY_EVENT = pygame.USEREVENT  # 定时器常量是一个整数
   # 第二步：设置定时器事件
   pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000) # 1000表示毫秒，表示每个1秒触发一次事件CREATE_ENEMY_EVENT
   # 第三步：循环监听定时器事件
   def __event__handleer(self):
     for event in pygame.event.get():
       if event.type == CREATE_ENEMY_EVENT:
         self.hero.fire()
   

1.4.9.2碰撞检测

1. pygame的两种实现碰撞的方法

   • 第一种方法：pygame.sprite.groupcollide()

     两个精灵组的所有精灵的碰撞检测
     groupcollide(group1, group2, dokill1, dokill2, collided = None) --> Sprite_dict
     # kokill1和group1有关，kokill2和group2有关；如果kokill1设置为True则如果group1发生碰撞则会将group1销毁
     # collided参数用来计算碰撞的回调函数，如果没有指定则每个精灵必须有一个rect属性
     

   • 第二种方法：pygame.sprite.spritecollide()

     spritecollide(sprite, group, dokill, collided = None) --> Sprite_list
     # 当dokill设置为True时，如果sprite发生碰撞则sprite会被销毁，返回的是精灵组中和精灵发生碰撞的精灵列表
     

1.4.10完整代码实现

1. plan_main.py

   import pygame
   from plane_sprites import *
   
   
   class PlaneGame(object):
       """飞机大战主游戏"""
   
       def __init__(self):
           print("游戏初始化")
   
           # 1. 创建游戏的窗口
           self.screen = pygame.display.set_mode(SCREEN_RECT.size)
           # 2. 创建游戏的时钟
           self.clock = pygame.time.Clock()
           # 3. 调用私有方法，精灵和精灵组的创建
           self.__create_sprites()
   
           # 4. 设置定时器事件 - 创建敌机　1s
           pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)
           pygame.time.set_timer(HERO_FIRE_EVENT, 500)
   
       def __create_sprites(self):
   
           # 创建背景精灵和精灵组
           bg1 = Background()
           bg2 = Background(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:
               # 1. 设置刷新帧率
               self.clock.tick(FRAME_PER_SEC)
               # 2. 事件监听
               self.__event_handler()
               # 3. 碰撞检测
               self.__check_collide()
               # 4. 更新/绘制精灵组
               self.__update_sprites()
               # 5. 更新显示
               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:
                   # print("敌机出场...")
                   # 创建敌机精灵
                   enemy = Enemy()
   
                   # 将敌机精灵添加到敌机精灵组
                   self.enemy_group.add(enemy)
               elif event.type == HERO_FIRE_EVENT:
                   self.hero.fire()
               # elif event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT:
               #     print("向右移动...")
   
           # 使用键盘提供的方法获取键盘按键 - 按键元组
           keys_pressed = pygame.key.get_pressed()
           # 判断元组中对应的按键索引值 1
           if keys_pressed[pygame.K_RIGHT]:
               self.hero.speed = 2
           elif keys_pressed[pygame.K_LEFT]:
               self.hero.speed = -2
           else:
               self.hero.speed = 0
   
       def __check_collide(self):
   
           # 1. 子弹摧毁敌机
           pygame.sprite.groupcollide(self.hero.bullets, self.enemy_group, True, True)
   
           # 2. 敌机撞毁英雄
           enemies = pygame.sprite.spritecollide(self.hero, self.enemy_group, True)
   
           # 判断列表时候有内容
           if len(enemies) > 0:
   
               # 让英雄牺牲
               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()
   
   

2. plan_sprites.py

   import random
   import pygame
   
   # 屏幕大小的常量
   SCREEN_RECT = pygame.Rect(0, 0, 480, 700)
   # 刷新的帧率
   FRAME_PER_SEC = 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(image_name)
           self.rect = self.image.get_rect()
           self.speed = speed
   
       def update(self):
   
           # 在屏幕的垂直方向上移动
           self.rect.y += self.speed
   
   
   class Background(GameSprite):
       """游戏背景精灵"""
   
       def __init__(self, is_alt=False):
   
           # 1. 调用父类方法实现精灵的创建(image/rect/speed)
           super().__init__("./images/background.png")
   
           # 2. 判断是否是交替图像，如果是，需要设置初始位置
           if is_alt:
               self.rect.y = -self.rect.height
   
       def update(self):
   
           # 1. 调用父类的方法实现
           super().update()
   
           # 2. 判断是否移出屏幕，如果移出屏幕，将图像设置到屏幕的上方
           if self.rect.y >= SCREEN_RECT.height:
               self.rect.y = -self.rect.height
   
   
   class Enemy(GameSprite):
       """敌机精灵"""
   
       def __init__(self):
   
           # 1. 调用父类方法，创建敌机精灵，同时指定敌机图片
           super().__init__("./images/enemy1.png")
   
           # 2. 指定敌机的初始随机速度 1 ~ 3
           self.speed = random.randint(1, 3)
   
           # 3. 指定敌机的初始随机位置
           self.rect.bottom = 0
   
           max_x = SCREEN_RECT.width - self.rect.width
           self.rect.x = random.randint(0, max_x)
   
       def update(self):
   
           # 1. 调用父类方法，保持垂直方向的飞行
           super().update()
   
           # 2. 判断是否飞出屏幕，如果是，需要从精灵组删除敌机
           if self.rect.y >= SCREEN_RECT.height:
               # print("飞出屏幕，需要从精灵组删除...")
               # kill方法可以将精灵从所有精灵组中移出，精灵就会被自动销毁
               self.kill()
   
       def __del__(self):
           # print("敌机挂了 %s" % self.rect)
           pass
   
   
   class Hero(GameSprite):
       """英雄精灵"""
   
       def __init__(self):
   
           # 1. 调用父类方法，设置image&speed
           super().__init__("./images/me1.png", 0)
   
           # 2. 设置英雄的初始位置
           # centerx表示居中属性(就是表示x轴的中心位置)，表示飞船x方向中心与屏幕x方向中心重合，也即x方向居中
           self.rect.centerx = SCREEN_RECT.centerx
           self.rect.bottom = SCREEN_RECT.bottom - 120  # bottom = y + height
   
           # 3. 创建子弹的精灵组
           self.bullets = pygame.sprite.Group()
   
       def update(self):
   
           # 英雄在水平方向移动
           self.rect.x += self.speed
   
           # 控制英雄不能离开屏幕
           # 保证英雄不能从左侧移出
           if self.rect.x < 0:
               self.rect.x = 0
           # 保证英雄不能从右侧移出
           elif self.rect.right > SCREEN_RECT.right:  # right = x + width
               self.rect.right = SCREEN_RECT.right
   
       def fire(self):
           print("发射子弹...")
           # 一次发射三颗子弹
           for i in (0, 1, 2):
               # 1. 创建子弹精灵
               bullet = Bullet()
   
               # 2. 设置精灵的位置
               bullet.rect.bottom = self.rect.y - i * 20
               bullet.rect.centerx = self.rect.centerx
   
               # 3. 将精灵添加到精灵组
               self.bullets.add(bullet)
   
   
   class Bullet(GameSprite):
       """子弹精灵"""
   
       def __init__(self):
   
           # 调用父类方法，设置子弹图片，设置初始速度
           super().__init__("./images/bullet1.png", -2)
   
       def update(self):
   
           # 调用父类方法，让子弹沿垂直方向飞行
           super().update()
   
           # 判断子弹是否飞出屏幕
           if self.rect.bottom < 0:
               self.kill()  # kill()方法可以将精灵从精灵组中删除
   
       def __del__(self):
           print("子弹被销毁...")