项目实战 —— 飞机大战
目标
- 强化 面向对象 程序设计
- 体验使用
pygame
模块进行 游戏开发
实战步骤
pygame
快速体验- 飞机大战 实战
确认模块 —— pygame
pygame
就是一个 Python 模块,专为电子游戏设计- 官方网站:https://www.pygame.org/
- 提示:要学习第三方模块,通常最好的参考资料就在官方网站
网站栏目 | 内容 |
---|---|
GettingStarted | 在各平台安装模块的说明 |
Docs | pygame 模块所有 类 和 子类 的参考手册 |
安装 pygame
$ sudo pip3 install pygame
验证安装
$ python3 -m pygame.examples.aliens
游戏框架搭建
目标 —— 使用 面相对象 设计 飞机大战游戏类
目标
- 明确主程序职责
- 实现主程序类
- 准备游戏精灵组
01. 明确主程序职责
- 回顾 快速入门案例,一个游戏主程序的 职责 可以分为两个部分:
- 游戏初始化
- 游戏循环
- 根据明确的职责,设计
PlaneGame
类如下:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lLleImdA-1588060746916)(media/15025159832322/009_%E6%B8%B8%E6%88%8F%E4%B8%BB%E7%A8%8B%E5%BA%8F.png)]
提示 根据 职责 封装私有方法,可以避免某一个方法的代码写得太过冗长
如果某一个方法编写的太长,既不好阅读,也不好维护!
- 游戏初始化 ——
__init__()
会调用以下方法:
方法 | 职责 |
---|---|
__create_sprites(self) | 创建所有精灵和精灵组 |
- 游戏循环 ——
start_game()
会调用以下方法:
方法 | 职责 |
---|---|
__event_handler(self) | 事件监听 |
__check_collide(self) | 碰撞检测 —— 子弹销毁敌机、敌机撞毁英雄 |
__update_sprites(self) | 精灵组更新和绘制 |
__game_over() | 游戏结束 |
02. 实现飞机大战主游戏类
2.1 明确文件职责
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GXPd8m0K-1588060746918)(media/15025159832322/011_%E7%A8%8B%E5%BA%8F%E6%96%87%E4%BB%B6%E8%81%8C%E8%B4%A3.png)]
plane_main
- 封装 主游戏类
- 创建 游戏对象
- 启动游戏
plane_sprites
- 封装游戏中 所有 需要使用的 精灵子类
- 提供游戏的 相关工具
代码实现
- 新建
plane_main.py
文件,并且设置为可执行 - 编写 基础代码
import pygame
from plane_sprites import *
class PlaneGame(object):
"""飞机大战主游戏"""
def __init__(self):
print("游戏初始化")
def start_game(self):
print("开始游戏...")
if __name__ == '__main__':
# 创建游戏对象
game = PlaneGame()
# 开始游戏
game.start_game()
2.3 游戏初始化部分
- 完成
__init__()
代码如下:
def __init__(self):
print("游戏初始化")
# 1. 创建游戏的窗口
self.screen = pygame.display.set_mode((480, 700))
# 2. 创建游戏的时钟
self.clock = pygame.time.Clock()
# 3. 调用私有方法,精灵和精灵组的创建
self.__create_sprites()
def __create_sprites(self):
pass
使用 常量 代替固定的数值
- 常量 —— 不变化的量
- 变量 —— 可以变化的量
应用场景
- 在开发时,可能会需要使用 固定的数值,例如 屏幕的高度 是
700
- 这个时候,建议 不要 直接使用固定数值,而应该使用 常量
- 在开发时,为了保证代码的可维护性,尽量不要使用 魔法数字
常量的定义
- 定义 常量 和 定义 变量 的语法完全一样,都是使用 赋值语句
- 常量 的 命名 应该 所有字母都使用大写,单词与单词之间使用下划线连接
常量的好处
- 阅读代码时,通过 常量名 见名之意,不需要猜测数字的含义
- 如果需要 调整值,只需要 修改常量定义 就可以实现 统一修改
提示:Python 中并没有真正意义的常量,只是通过命名的约定 —— 所有字母都是大写的就是常量,开发时不要轻易的修改!
代码调整
- 在
plane_sprites.py
中增加常量定义
import pygame
# 游戏屏幕大小
SCREEN_RECT = pygame.Rect(0, 0, 480, 700)
- 修改
plane_main.py
中的窗口大小
self.screen = pygame.display.set_mode(SCREEN_RECT.size)
2.4 游戏循环部分
- 完成
start_game()
基础代码如下:
def start_game(self):
"""开始游戏"""
print("开始游戏...")
while True:
# 1. 设置刷新帧率
self.clock.tick(60)
# 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()
def __check_collide(self):
"""碰撞检测"""
pass
def __update_sprites(self):
"""更新精灵组"""
pass
@staticmethod
def __game_over():
"""游戏结束"""
print("游戏结束")
pygame.quit()
exit()
03. 准备游戏精灵组
3.1 确定精灵组
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PF4fTvKJ-1588060746919)(media/15025159832322/010_%E7%B2%BE%E7%81%B5%E7%BB%84%E7%A1%AE%E5%AE%9A.png)]
3.2 代码实现
- 创建精灵组方法
def __create_sprites(self):
"""创建精灵组"""
# 背景组
self.back_group = pygame.sprite.Group()
# 敌机组
self.enemy_group = pygame.sprite.Group()
# 英雄组
self.hero_group = pygame.sprite.Group()
- 更新精灵组方法
def __update_sprites(self):
"""更新精灵组"""
for group in [self.back_group, self.enemy_group, self.hero_group]:
group.update()
group.draw(self.screen)
游戏背景
目标
- 背景交替滚动的思路确定
- 显示游戏背景
01. 背景交替滚动的思路确定
运行 备课代码,观察 背景图像的显示效果:
- 游戏启动后,背景图像 会 连续不断地 向下方 移动
- 在 视觉上 产生英雄的飞机不断向上方飞行的 错觉 —— 在很多跑酷类游戏中常用的套路
- 游戏的背景 不断变化
- 游戏的主角 位置保持不变
1.1 实现思路分析
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PwlvUaHf-1588060760964)(media/15025262948537/013_%E8%83%8C%E6%99%AF%E5%9B%BE%E7%89%87%E4%BA%A4%E6%9B%BF%E6%BB%9A%E5%8A%A8.png)]
解决办法
- 创建两张背景图像精灵
- 第
1
张 完全和屏幕重合 - 第
2
张在 屏幕的正上方
- 第
- 两张图像 一起向下方运动
self.rect.y += self.speed
- 当 任意背景精灵 的
rect.y >= 屏幕的高度
说明已经 移动到屏幕下方 - 将 移动到屏幕下方的这张图像 设置到 屏幕的正上方
rect.y = -rect.height
1.2 设计背景类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uphdcn1R-1588060760965)(media/15025262948537/012_%E6%B4%BE%E7%94%9FBackground%E5%AD%90%E7%B1%BB.png)]
- 初始化方法
- 直接指定 背景图片
is_alt
判断是否是另一张图像False
表示 第一张图像,需要与屏幕重合True
表示 另一张图像,在屏幕的正上方
- update() 方法
- 判断 是否移动出屏幕,如果是,将图像设置到 屏幕的正上方,从而实现 交替滚动
继承 如果父类提供的方法,不能满足子类的需求:
- 派生一个子类
- 在子类中针对特有的需求,重写父类方法,并且进行扩展
02. 显示游戏背景
2.1 背景精灵的基本实现
- 在
plane_sprites
新建Background
继承自GameSprite
class Background(GameSprite):
"""游戏背景精灵"""
def update(self):
# 1. 调用父类的方法实现
super().update()
# 2. 判断是否移出屏幕,如果移出屏幕,将图像设置到屏幕的上方
if self.rect.y >= SCREEN_RECT.height:
self.rect.y = -self.rect.height
2.2 在 plane_main.py
中显示背景精灵
- 在
__create_sprites
方法中创建 精灵 和 精灵组 - 在
__update_sprites
方法中,让 精灵组 调用update()
和draw()
方法
__create_sprites
方法
def __create_sprites(self):
# 创建背景精灵和精灵组
bg1 = Background("./images/background.png")
bg2 = Background("./images/background.png")
bg2.rect.y = -bg2.rect.height
self.back_group = pygame.sprite.Group(bg1, bg2)
__update_sprites
方法
def __update_sprites(self):
self.back_group.update()
self.back_group.draw(self.screen)
2.3 利用初始化方法,简化背景精灵创建
思考 —— 上一小结完成的代码存在什么样的问题?能否简化?
- 在主程序中,创建的两个背景精灵,传入了相同的图像文件路径
- 创建 第二个 背景精灵 时,在主程序中,设置背景精灵的图像位置
思考 —— 精灵 初始位置 的设置,应该 由主程序负责?还是 由精灵自己负责?
答案 —— 由精灵自己负责
- 根据面向对象设计原则,应该将对象的职责,封装到类的代码内部
- 尽量简化程序调用一方的代码调用
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CR2V8cit-1588060760966)(media/15025262948537/012_%E6%B4%BE%E7%94%9FBackground%E5%AD%90%E7%B1%BB.png)]
- 初始化方法
- 直接指定 背景图片
is_alt
判断是否是另一张图像False
表示 第一张图像,需要与屏幕重合True
表示 另一张图像,在屏幕的正上方
在 plane_sprites.py
中实现 Background
的 初始化方法
def __init__(self, is_alt=False):
image_name = "./images/background.png"
super().__init__(image_name)
# 判断是否交替图片,如果是,将图片设置到屏幕顶部
if is_alt:
self.rect.y = -self.rect.height
- 修改
plane_main
的__create_sprites
方法
# 创建背景精灵和精灵组
bg1 = Background()
bg2 = Background(True)
self.back_group = pygame.sprite.Group(bg1, bg2)
敌机出场
目标
- 使用 定时器 添加敌机
- 设计
Enemy
类
01. 使用定时器添加敌机
运行 备课代码,观察 敌机的 出现规律:
- 游戏启动后,每隔 1 秒 会 出现一架敌机
- 每架敌机 向屏幕下方飞行,飞行 速度各不相同
- 每架敌机出现的 水平位置 也不尽相同
- 当敌机 从屏幕下方飞出,不会再飞回到屏幕中
1.1 定时器
- 在
pygame
中可以使用pygame.time.set_timer()
来添加 定时器 - 所谓 定时器,就是 每隔一段时间,去 执行一些动作
set_timer(eventid, milliseconds) -> None
set_timer
可以创建一个 事件- 可以在 游戏循环 的 事件监听 方法中捕获到该事件
- 第 1 个参数 事件代号 需要基于常量
pygame.USEREVENT
来指定USEREVENT
是一个整数,再增加的事件可以使用USEREVENT + 1
指定,依次类推…
- 第 2 个参数是 事件触发 间隔的 毫秒值
定时器事件的监听
- 通过
pygame.event.get()
可以获取当前时刻所有的 事件列表 - 遍历列表 并且判断
event.type
是否等于eventid
,如果相等,表示 定时器事件 发生
1.2 定义并监听创建敌机的定时器事件
pygame
的 定时器 使用套路非常固定:
- 定义 定时器常量 ——
eventid
- 在 初始化方法 中,调用
set_timer
方法 设置定时器事件 - 在 游戏循环 中,监听定时器事件
1) 定义事件
- 在
plane_sprites.py
的顶部定义 事件常量
# 敌机的定时器事件常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
- 在
PlaneGame
的 初始化方法 中 创建用户事件
# 4. 设置定时器事件 - 每秒创建一架敌机
pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)
2) 监听定时器事件
- 在
__event_handler
方法中增加以下代码:
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("敌机出场...")
02. 设计 Enemy
类
- 游戏启动后,每隔 1 秒 会 出现一架敌机
- 每架敌机 向屏幕下方飞行,飞行 速度各不相同
- 每架敌机出现的 水平位置 也不尽相同
- 当敌机 从屏幕下方飞出,不会再飞回到屏幕中
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZXzyYMk9-1588060870127)(media/15025309517247/014_%E6%B4%BE%E7%94%9FEnemy%E5%AD%90%E7%B1%BB.png)]
- 初始化方法
- 指定 敌机图片
- 随机 敌机的 初始位置 和 初始速度
- 重写 update() 方法
- 判断 是否飞出屏幕,如果是,从 精灵组 删除
2.1 敌机类的准备
- 在
plane_sprites
新建Enemy
继承自GameSprite
- 重写 初始化方法,直接指定 图片名称
- 暂时 不实现 随机速度 和 随机位置 的指定
- 重写
update
方法,判断是否飞出屏幕
class Enemy(GameSprite):
"""敌机精灵"""
def __init__(self):
# 1. 调用父类方法,创建敌机精灵,并且指定敌机的图像
super().__init__("./images/enemy1.png")
# 2. 设置敌机的随机初始速度
# 3. 设置敌机的随机初始位置
def update(self):
# 1. 调用父类方法,让敌机在垂直方向运动
super().update()
# 2. 判断是否飞出屏幕,如果是,需要将敌机从精灵组删除
if self.rect.y >= SCREEN_RECT.height:
print("敌机飞出屏幕...")
2.2 创建敌机
演练步骤
- 在
__create_sprites
,添加 敌机精灵组- 敌机是 定时被创建的,因此在初始化方法中,不需要创建敌机
- 在
__event_handler
,创建敌机,并且 添加到精灵组- 调用 精灵组 的
add
方法可以 向精灵组添加精灵
- 调用 精灵组 的
- 在
__update_sprites
,让 敌机精灵组 调用update
和draw
方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aLuVFDrC-1588060870128)(media/15025309517247/006_pygame.SpriteII.png)]
演练代码
- 修改
plane_main
的__create_sprites
方法
# 敌机组
self.enemy_group = pygame.sprite.Group()
- 修改
plane_main
的__update_sprites
方法
self.enemy_group.update()
self.enemy_group.draw(self.screen)
- 定时出现敌机
elif event.type == CREATE_ENEMY_EVENT:
self.enemy_group.add(Enemy())
2.3 随机敌机位置和速度
1) 导入模块
- 在导入模块时,建议 按照以下顺序导入
1. 官方标准模块导入
2. 第三方模块导入
3. 应用程序模块导入
- 修改
plane_sprites.py
增加random
的导入
import random
2) 随机位置
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uIMCHRpt-1588060870129)(media/15025309517247/015_%E9%A3%9E%E6%9C%BA%E5%88%9D%E5%A7%8B%E4%BD%8D%E7%BD%AE.png)]
使用 pygame.Rect
提供的 bottom
属性,在指定敌机初始位置时,会比较方便
bottom = y + height
y = bottom - height
3) 代码实现
- 修改 初始化方法,随机敌机出现 速度 和 位置
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)
2.4 移出屏幕销毁敌机
- 敌机移出屏幕之后,如果 没有撞到英雄,敌机的历史使命已经终结
- 需要从 敌机组 删除,否则会造成 内存浪费
检测敌机被销毁
__del__
内置方法会在对象被销毁前调用,在开发中,可以用于 判断对象是否被销毁
def __del__(self):
print("敌机挂了 %s" % self.rect)
代码实现
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iLu2AGeP-1588060870130)(media/15025309517247/006_pygame.SpriteII.png)]
- 判断敌机是否飞出屏幕,如果是,调用
kill()
方法从所有组中删除
def update(self):
super().update()
# 判断敌机是否移出屏幕
if self.rect.y >= SCREEN_RECT.height:
# 将精灵从所有组中删除
self.kill()
英雄登场
目标
- 设计 英雄 和 子弹 类
- 使用
pygame.key.get_pressed()
移动英雄 - 发射子弹
01. 设计 英雄 和 子弹 类
英雄需求
- 游戏启动后,英雄 出现在屏幕的 水平中间 位置,距离 屏幕底部
120
像素 - 英雄 每隔
0.5
秒发射一次子弹,每次 连发三枚子弹 - 英雄 默认不会移动,需要通过 左/右 方向键,控制 英雄 在水平方向移动
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Wazoi0U-1588060882586)(media/15025349250200/017_%E8%8B%B1%E9%9B%84%E4%BD%8D%E7%BD%AE.png)]
子弹需求
- 子弹 从 英雄 的正上方发射 沿直线 向 上方 飞行
- 飞出屏幕后,需要从 精灵组 中删除
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HExT3jZ4-1588060882587)(media/15025349250200/016_%E6%B4%BE%E7%94%9F%E8%8B%B1%E9%9B%84%E5%92%8C%E5%AD%90%E5%BC%B9%E5%AD%90%E7%B1%BB.png)]
Hero —— 英雄
- 初始化方法
- 指定 英雄图片
- 初始速度 = 0 —— 英雄默认静止不动
- 定义
bullets
子弹精灵组 保存子弹精灵
- 重写 update() 方法
- 英雄需要 水平移动
- 并且需要保证不能 移出屏幕
- 增加
bullets
属性,记录所有 子弹精灵 - 增加
fire
方法,用于发射子弹
Bullet —— 子弹
- 初始化方法
- 指定 子弹图片
- 初始速度 = -2 —— 子弹需要向上方飞行
- 重写 update() 方法
- 判断 是否飞出屏幕,如果是,从 精灵组 删除
02. 创建英雄
2.1 准备英雄类
- 在
plane_sprites
新建Hero
类 - 重写 初始化方法,直接指定 图片名称,并且将初始速度设置为
0
- 设置 英雄的初始位置
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jdqIaQvZ-1588060882587)(media/15025349250200/003_pygame.Rect.png)]
centerx = x + 0.5 * width
centery = y + 0.5 * height
bottom = y + height
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jX2uNr8O-1588060882588)(media/15025349250200/017_%E8%8B%B1%E9%9B%84%E4%BD%8D%E7%BD%AE.png)]
class Hero(GameSprite):
"""英雄精灵"""
def __init__(self):
super().__init__("./images/me1.png", 0)
# 设置初始位置
self.rect.centerx = SCREEN_RECT.centerx
self.rect.bottom = SCREEN_RECT.bottom - 120
2.2 绘制英雄
- 在
__create_sprites
,添加 英雄精灵 和 英雄精灵组- 后续要针对 英雄 做 碰撞检测 以及 发射子弹
- 所以 英雄 需要 单独定义成属性
- 在
__update_sprites
,让 英雄精灵组 调用update
和draw
方法
代码实现
- 修改
__create_sprites
方法如下:
# 英雄组
self.hero = Hero()
self.hero_group = pygame.sprite.Group(self.hero)
- 修改
__update_sprites
方法如下:
self.hero_group.update()
self.hero_group.draw(self.screen)
03. 移动英雄位置
在
pygame
中针对 键盘按键的捕获,有 两种 方式
- 第一种方式 判断
event.type == pygame.KEYDOWN
- 第二种方式
- 首先使用
pygame.key.get_pressed()
返回 所有按键元组 - 通过 键盘常量,判断元组中 某一个键是否被按下 —— 如果被按下,对应数值为
1
- 首先使用
提问 这两种方式之间有什么区别呢?
- 第一种方式
elif event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT:
print("向右移动...")
- 第二种方式
# 返回所有按键的元组,如果某个键被按下,对应的值会是1
keys_pressed = pygame.key.get_pressed()
# 判断是否按下了方向键
if keys_pressed[pygame.K_RIGHT]:
print("向右移动...")
结论
- 第一种方式
event.type
用户 必须要抬起按键 才算一次 按键事件,操作灵活性会大打折扣 - 第二种方式 用户可以按住方向键不放,就能够实现持续向某一个方向移动了,操作灵活性更好
3.1 移动英雄位置
演练步骤
- 在
Hero
类中重写update
方法- 用 速度
speed
和 英雄rect.x
进行叠加 - 不需要调用父类方法 —— 父类方法只是实现了单纯的垂直运动
- 用 速度
- 在
__event_handler
方法中根据 左右方向键 设置英雄的 速度- 向右 =>
speed = 2
- 向左 =>
speed = -2
- 其他 =>
speed = 0
- 向右 =>
代码演练
- 在
Hero
类,重写update()
方法,根据速度水平移动 英雄的飞机
def update(self):
# 飞机水平移动
self.rect.x += self.speed
- 调整键盘按键代码
# 获取用户按键
keys_pressed = pygame.key.get_pressed()
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
3.2 控制英雄运动边界
- 在
Hero
类的update()
方法判断 英雄 是否超出 屏幕边界
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JzCENVKf-1588060882588)(media/15025349250200/003_pygame.Rect.png)]
right = x + width
利用right
属性可以非常容易的针对右侧设置精灵位置
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hBEWIhhN-1588060882589)(media/15025349250200/017_%E8%8B%B1%E9%9B%84%E4%BD%8D%E7%BD%AEII.png)]
def update(self):
# 飞机水平移动
self.rect.x += self.speed
# 判断屏幕边界
if self.rect.left < 0:
self.rect.left = 0
if self.rect.right > SCREEN_RECT.right:
self.rect.right = SCREEN_RECT.right
04. 发射子弹
需求回顾 —— 英雄需求
- 游戏启动后,英雄 出现在屏幕的 水平中间 位置,距离 屏幕底部
120
像素 - 英雄 每隔
0.5
秒发射一次子弹,每次 连发三枚子弹 - 英雄 默认不会移动,需要通过 左/右 方向键,控制 英雄 在水平方向移动
4.1 添加发射子弹事件
pygame
的 定时器 使用套路非常固定:
- 定义 定时器常量 ——
eventid
- 在 初始化方法 中,调用
set_timer
方法 设置定时器事件 - 在 游戏循环 中,监听定时器事件
代码实现
- 在
Hero
中定义fire
方法
def fire(self):
print("发射子弹...")
- 在
plane_main.py
的顶部定义 发射子弹 事件常量
# 英雄发射子弹事件
HERO_FIRE_EVENT = pygame.USEREVENT + 1
- 在
__init__
方法末尾中添加 发射子弹 事件
# 每隔 0.5 秒发射一次子弹
pygame.time.set_timer(HERO_FIRE_EVENT, 500)
- 在
__event_handler
方法中让英雄发射子弹
elif event.type == HERO_FIRE_EVENT:
self.hero.fire()
4.2 定义子弹类
需求回顾 —— 子弹需求
- 子弹 从 英雄 的正上方发射 沿直线 向 上方 飞行
- 飞出屏幕后,需要从 精灵组 中删除
Bullet —— 子弹
- 初始化方法
- 指定 子弹图片
- 初始速度 = -2 —— 子弹需要向上方飞行
- 重写 update() 方法
- 判断 是否飞出屏幕,如果是,从 精灵组 删除
定义子弹类
- 在
plane_sprites
新建Bullet
继承自GameSprite
- 重写 初始化方法,直接指定 图片名称,并且设置 初始速度
- 重写
update()
方法,判断子弹 飞出屏幕从精灵组删除
class Bullet(GameSprite):
"""子弹精灵"""
def __init__(self):
super().__init__("./images/bullet1.png", -2)
def update(self):
super().update()
# 判断是否超出屏幕,如果是,从精灵组删除
if self.rect.bottom < 0:
self.kill()
4.3 发射子弹
演练步骤
- 在
Hero
的 初始化方法 中创建 子弹精灵组 属性 - 修改
plane_main.py
的__update_sprites
方法,让 子弹精灵组 调用update
和draw
方法 - 实现
fire()
方法- 创建子弹精灵
- 设置初始位置 —— 在 英雄的正上方
- 将 子弹 添加到精灵组
代码实现
- 初始化方法
# 创建子弹的精灵组
self.bullets = pygame.sprite.Group()
- 修改
fire()
方法
def fire(self):
# 1. 创建子弹精灵
bullet = Bullet()
# 2. 设置精灵的位置
bullet.rect.bottom = self.rect.y - 20
bullet.rect.centerx = self.rect.centerx
# 3. 将精灵添加到精灵组
self.bullets.add(bullet)
一次发射三枚子弹
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OxbcAy2R-1588060882589)(media/15025349250200/017_%E8%8B%B1%E9%9B%84%E4%BD%8D%E7%BD%AEIII.png)]
- 修改
fire()
方法,一次发射三枚子弹
def fire(self):
for i in (1, 2, 3):
# 1. 创建子弹精灵
bullet = Bullet()
# 2. 设置精灵的位置
bullet.rect.bottom = self.rect.y - i * 20
bullet.rect.centerx = self.rect.centerx
# 3. 将精灵添加到精灵组
self.bullets.add(bullet)
碰撞检测
目标
- 了解碰撞检测方法
- 碰撞实现
01. 了解碰撞检测方法
pygame
提供了 两个非常方便 的方法可以实现碰撞检测:
pygame.sprite.groupcollide()
- 两个精灵组 中 所有的精灵 的碰撞检测
groupcollide(group1, group2, dokill1, dokill2, collided = None) -> Sprite_dict
- 如果将
dokill
设置为True
,则 发生碰撞的精灵将被自动移除 collided
参数是用于 计算碰撞的回调函数- 如果没有指定,则每个精灵必须有一个
rect
属性
- 如果没有指定,则每个精灵必须有一个
pygame.sprite.spritecollide()
- 判断 某个精灵 和 指定精灵组 中的精灵的碰撞
spritecollide(sprite, group, dokill, collided = None) -> Sprite_list
- 如果将
dokill
设置为True
,则 指定精灵组 中 发生碰撞的精灵将被自动移除 collided
参数是用于 计算碰撞的回调函数- 如果没有指定,则每个精灵必须有一个
rect
属性
- 如果没有指定,则每个精灵必须有一个
- 返回 精灵组 中跟 精灵 发生碰撞的 精灵列表
02. 碰撞实现
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()