手把手教你使用Pygame制作飞机大战小游戏，4万字超详细讲解！
16lz
2021-01-22
大家好，偷学Python系列是由小甜同学从初学者的角度学习Python的笔记，其特点就是全文大多由新手易理解的代码与注释及动态演示。刚入门的读者千万不要错过！
本文带来的是偷学Python最后的项目二：使用Python开发飞机大战游戏，本文目录如下
甜甜先说
这次用Python中的pygame模块来完成一个飞机大战的小游戏；基本思路是通过方向键来控制飞机的左右移动射击飞船。先来看下最后的效果
为了新手也能完成，本文记录了编写的全部流程，也就是每次修改的代码也包括在内，并且给大多数代码都加上了能看懂的注释，看一下最终的的统计字数
一共敲了4万个字符，希望能帮到感兴趣的读者！
安装Pygame
要完成这个项目肯定要安装pygame第三方库，首先通过命令行工具检测系统是否安装的pip工具
python -m pip --version
小甜是Windows系统，这里只提供Windows系统的检测方法 如果未安装则安装pip工具，安装则请跳过这一步
python get-pip.py
安装完毕以后退回第一步重新检测,现在安装pygame
python -m pip install pygame --user
或者通过pycharm安装第三个库，现在导入pygame即可
import pygame
制作小飞机
搞起来
目标：创建一个可以左右移动的小飞机，用户可以通过空格space键来控制飞机发射子弹。
创建背景
创建一个空背景
首先编写一个空的pygame窗口，文件名为plane_war.py
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
import sys # 用于退出游戏
def run_game():
# 初始化游戏
pygame.init()
# 设置屏幕的分辨率
screen = pygame.display.set_mode((1000, 600)) # 大小为1000px乘以600px
# 打印其类型
# print(type(screen)) # <class 'pygame.Surface'>
pygame.display.set_caption("飞机大战") # 标题
# 存储背景的变量
bg_img = pygame.image.load("./imgs/bg_img.png") # 相对路径
print(bg_img)
# 开始游戏的主循环
while True:
# 为了防止游戏窗口启动会立马关闭，在其中增加一个游戏循环(无限循环)，
for event in pygame.event.get():
# 每次循环都会重新绘制屏幕
screen.blit(bg_img, [0, 0]) # 绘制图像
if event.type == pygame.QUIT: # QUIT用户请求程序关闭
sys.exit()
# 将完整显示Surface更新到屏幕
pygame.display.flip()
run_game()
display.set_mode返回的是一个Surface数据类型
效果图
创建设置类
一个游戏通常有n多个设置，如果每次想改变其中的某一个值的话在主文件中寻找容易眼花缭乱，现在创建一个新的文件settings.py，专门用来存储这些信息
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
class Settings:
"""存储飞机大战的所有设置"""
def __init__(self):
# 屏幕设置
self.screen_width = 1000
self.screen_height = 600
self.bg_img = pygame.image.load("./imgs/bg_img.png")
现在来改写plane_war.py
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
import sys # 用于退出游戏
from settings import Settings # 引入settings.py
def run_game():
# 初始化游戏
pygame.init()
# 设置屏幕的分辨率
setting = Settings()
screen = pygame.display.set_mode((setting.screen_width, setting.screen_height))
pygame.display.set_caption("飞机大战") # 标题
# 开始游戏的主循环
while True:
# 为了防止游戏窗口启动会立马关闭，在其中增加一个游戏循环(无限循环)，
for event in pygame.event.get():
# 每次循环都会重新绘制屏幕
screen.blit(setting.bg_img, [0, 0]) # 绘制图像
if event.type == pygame.QUIT: # QUIT用户请求程序关闭
sys.exit()
# 将完整显示Surface更新到屏幕
pygame.display.flip()
run_game()
添加小飞机
这里用到的小飞机
绘制小飞机
现在图像也有了，来创建一个plane.py模块，其中有一个Plane类，来存储飞机的各种行为
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
class Plane:
def __init__(self, screen):
# 初始化小飞机并设置其初始位置
self.screen = screen
# 加载图像，并获得其矩形区域
self.img_plane = pygame.image.load("./imgs/plane.png")
self.rect = self.img_plane.get_rect() # 得到小飞机的的矩形区域
self.screen_rect = self.screen.get_rect() # 得到screen的矩形区域
# 将小飞机放到底部中央
self.rect.centerx = self.screen_rect.centerx # 水平居中
self.rect.bottom = self.screen_rect.bottom # 底部
def blitme(self):
# 在指定位置绘制小飞机
self.screen.blit(self.img_plane, self.rect)
get_rect会返回Surface的矩形的区域，.centerx和.bottom是其两个属性
改写plane_war.py将小飞机绘制在屏幕上
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
import sys # 用于退出游戏
from settings import Settings # 引入settings.py
from plane import Plane
def run_game():
# 初始化游戏
pygame.init()
# 设置屏幕的分辨率
setting = Settings()
screen = pygame.display.set_mode((setting.screen_width, setting.screen_height)) # 大小为1000px乘以600px
pygame.display.set_caption("飞机大战") # 标题
# 创建小飞机
plane = Plane(screen)
# 开始游戏的主循环
while True:
# 为了防止游戏窗口启动会立马关闭，在其中增加一个游戏循环(无限循环)，
for event in pygame.event.get():
# 每次循环都会重新绘制屏幕
screen.blit(setting.bg_img, [0, 0]) # 绘制图像
plane.blitme() # 将飞船绘制到屏幕上
if event.type == pygame.QUIT: # QUIT用户请求程序关闭
sys.exit()
# 将完整显示Surface更新到屏幕
pygame.display.flip()
run_game()
效果图
创建一个存储运行函数的模块
为了不使plane_war.py太长而影响阅读，来创建一个名为game_func.py的模块，用其飞机大战运行的函数，使其逻辑更容易理解
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import sys
import pygame
def check_events():
# 为了防止游戏窗口启动会立马关闭，在其中增加一个游戏循环(无限循环)，
for event in pygame.event.get():
if event.type == pygame.QUIT: # QUIT用户请求程序关闭
sys.exit()
def update_screen(screen, bg_img, plane):
# 更新屏幕的图像
# 每次循环都会重新绘制屏幕
screen.blit(bg_img, [0, 0]) # 绘制图像
plane.blitme() # 将飞船绘制到屏幕上
# 将完整显示Surface更新到屏幕
pygame.display.flip()
check_events函数用来完成窗口不会关闭的功能，update_screen用来完成更新图像的功能，有3个形参，Surface对象、背景图像、小飞机函数
因为check_events完成了退出游戏的操作，所以plane_war.py就不需要sys模块了，更新后的plane_war.py如下
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
from settings import Settings # 引入settings.py
from plane import Plane
import game_func as fg
def run_game():
# 初始化游戏
pygame.init()
# 设置屏幕的分辨率
setting = Settings()
screen = pygame.display.set_mode((setting.screen_width, setting.screen_height)) # 大小为1000px乘以600px
pygame.display.set_caption("飞机大战") # 标题
# 创建小飞机
plane = Plane(screen)
# 开始游戏的主循环
while True:
# 不关闭窗口
fg.check_events()
# 绘制图像
fg.update_screen(screen, setting.bg_img, plane)
run_game()
控制小飞机
通过修改小飞机的坐标来完成移动，在用户按下方向键的时候小飞机的坐标进行有规律的变化
控制小飞机移动
当用户按键时，都会在pygame中注册一个事件，任何一个事件都是通过pygame.event.get()获取的，因此可以在函数体内，为每个按键都注册一个KEYDOWN事件。
现在将check_events函数改写，通过检测按下键位，来对小飞机进行移动
def check_events(plane):
# 为了防止游戏窗口启动会立马关闭，在其中增加一个游戏循环(无限循环)，
for event in pygame.event.get():
if event.type == pygame.QUIT: # QUIT用户请求程序关闭
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT:
# 小飞机往又移动
plane.rect.centerx += 1
现在按一下小飞机移动一个像素，一般的游戏都是通过按下不送则一直移动，
Pygame中的pygame.KEYUP可以检测用户是否松开按键 现在结合KEYDOWN和KEYUP来完成一个持续移动
控制小飞机持续移动
来定义一个标志位，来判断用户是否按下按键，默认为Flase一旦检测到用户按下俺家则为True，小飞机就可以持续移动
由于小飞机是通过plane.py文件来控制的，对这个文件进行改写
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
class Plane:
def __init__(self, screen):
# 初始化小飞机并设置其初始位置
self.screen = screen
# 加载图像，并获得其矩形区域
self.img_plane = pygame.image.load("./imgs/plane.png")
self.rect = self.img_plane.get_rect() # 得到小飞机的的矩形区域
self.screen_rect = self.screen.get_rect() # 得到screen的矩形区域
# print(self.screen_rect)
# 将小飞机放到底部中央
self.rect.centerx = self.screen_rect.centerx # 水平居中
self.rect.bottom = self.screen_rect.bottom # 底部
# 标志位
self.mv_right = False
# 定义一个调整小飞机位置的方法
def update(self):
# 根据标志位的调整小飞机的位置
if self.mv_right:
self.rect.centerx += 1
def blitme(self):
# 在指定位置绘制小飞机
self.screen.blit(self.img_plane, self.rect)
update方法是标志位为True时，小飞机就开始移动
改写game_func.py中的check_events函数
def check_events(plane):
# 为了防止游戏窗口启动会立马关闭，在其中增加一个游戏循环(无限循环)，
for event in pygame.event.get():
if event.type == pygame.QUIT: # QUIT用户请求程序关闭
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT:
# 当用户按下键位时标志位为True
plane.mv_right = True
elif event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT:
# 当用户松开键位为false
plane.mv_right = False
最后只要在plane_war.py中调用update方法就可以完成持续移动的操作
完成左右移动
用同样的方法完成向左移动
改写后的plane.py文件
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
class Plane:
def __init__(self, screen):
# 初始化小飞机并设置其初始位置
self.screen = screen
# 加载图像，并获得其矩形区域
self.img_plane = pygame.image.load("./imgs/plane.png")
self.rect = self.img_plane.get_rect() # 得到小飞机的的矩形区域
self.screen_rect = self.screen.get_rect() # 得到screen的矩形区域
# print(self.screen_rect)
# 将小飞机放到底部中央
self.rect.centerx = self.screen_rect.centerx # 水平居中
self.rect.bottom = self.screen_rect.bottom # 底部
# 标志位
self.mv_right = False
self.mv_left = False
# 定义一个调整小飞机位置的方法
def update(self):
# 根据标志位的调整小飞机的位置
if self.mv_right:
self.rect.centerx += 1
if self.mv_left:
self.rect.centerx -= 1
def blitme(self):
# 在指定位置绘制小飞机
self.screen.blit(self.img_plane, self.rect)
改写后的game_func.py中的check_events函数
def check_events(plane):
# 为了防止游戏窗口启动会立马关闭，在其中增加一个游戏循环(无限循环)，
for event in pygame.event.get():
if event.type == pygame.QUIT: # QUIT用户请求程序关闭
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT:
# 当用户按下键位时标志位为True
plane.mv_right = True
elif event.key == pygame.K_LEFT:
plane.mv_left = True
elif event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT:
# 当用户松开键位为false
plane.mv_right = False
elif event.key == pygame.K_LEFT:
plane.mv_left = False
调整速度
现在的小飞机一次是按1px来移动的，那速度是相当的缓慢，修改一下小飞机的移动速度
首先在setting.py中添加一行
self.plane_speed = 2.5
现在对plane.py做修改
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
class Plane:
def __init__(self, screen, setting):
# 初始化小飞机并设置其初始位置
self.screen = screen
self.setting = setting # 实例化属性
# 加载图像，并获得其矩形区域
self.img_plane = pygame.image.load("./imgs/plane.png")
self.rect = self.img_plane.get_rect() # 得到小飞机的的矩形区域
self.screen_rect = self.screen.get_rect() # 得到screen的矩形区域
# print(self.screen_rect)
# 将小飞机放到底部中央
self.rect.centerx = self.screen_rect.centerx # 水平居中
self.rect.bottom = self.screen_rect.bottom # 底部
# 将其修改为浮点数
self.center = float(self.rect.centerx)
# 标志位
self.mv_right = False
self.mv_left = False
# 定义一个调整小飞机位置的方法
def update(self):
# 根据标志位的调整小飞机的位置
if self.mv_right:
self.center += self.setting.plane_speed # settings中的属性
if self.mv_left:
self.center -= self.setting.plane_speed
# 根据self.center的值来更新self.rect.centerx
self.rect.centerx = self.center
def blitme(self):
# 在指定位置绘制小飞机
self.screen.blit(self.img_plane, self.rect)
将plane_war.py中的plane增加一个属性
plane = Plane(screen, setting)
限制小飞机的活动范围
现在小飞机已经可以飞呀飞，但是没有东西限制他，很容易就飞出了屏幕。现在将其限制在屏幕中，避免飞出去。
只需要修改plane.py中的update方法
重构game_func.py中的check_events函数
随着小飞机的功能愈来愈多，现在将check_events重构为3个函数，捕捉用户按键和用户松开键分别定义两个函数
重构后的check_events
def check_keydown_events(event, plane):
# 捕捉用户按下
if event.key == pygame.K_RIGHT:
# 当用户按下键位时标志位为True
plane.mv_right = True
elif event.key == pygame.K_LEFT:
plane.mv_left = True
def check_keyup_events(event, plane):
# 捕捉用户松开
if event.key == pygame.K_RIGHT:
# 当用户松开键位为false
plane.mv_right = False
elif event.key == pygame.K_LEFT:
plane.mv_left = False
def check_events(plane):
# 为了防止游戏窗口启动会立马关闭，在其中增加一个游戏循环(无限循环)，
for event in pygame.event.get():
if event.type == pygame.QUIT: # QUIT用户请求程序关闭
sys.exit()
elif event.type == pygame.KEYDOWN:
check_keydown_events(event, plane)
elif event.type == pygame.KEYUP:
check_keyup_events(event, plane)
效果图
完成射击功能
通过玩家按下空格来发射子弹(一小小小的矩形)
添加子弹的设置
在settings.py中的__init__方法中添加以下数据
# 子弹的设置
self.bullet_speed = 3 # 速度
self.bullet_width = 3 # 子弹的宽
self.bullet_height = 15 # 子弹的高
self.bullet_color = 100, 100, 100 # 子弹的颜色
创建Bullet类
创建存储子弹的Bullet类的bullet.py文件
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
from pygame.sprite import Sprite
class Bullet(Sprite): # 继承pygame.sprite中的Sprite类
"""子弹的管理"""
def __init__(self, setting, screen, plane):
super().__init__()
self.screen = screen
# 在(0,0)处创建一个表示子弹的矩形
# pygame.Rect
# 用于存储直角坐标的pygame对象
self.rect = pygame.Rect(0,0, setting.self.bullet_width, setting.self.bullet_height)
# 设置显示的位置
self.rect.centerx = plane.rect.centerx
self.rect.top = plane.rect.top
# 让子弹的位置跟小飞机重叠，当子弹飞出了以后，就显得跟从小飞机里面射出来一样
# 将子弹的坐标转换为浮点数
self.y = float(self.rect.y)
# 子弹的颜色
self.color = setting.bullet.color
# 子弹的速度
self.speed = setting.bullet.speed
def update(self):
# 向上移动子弹
self.y -= self.speed
# 根据self.y的值更新self.rect.y
self.rect.y = self.y
def draw_bullet(self):
"""绘制子弹"""
# pygame.draw.rect（）画一个矩形的形状
pygame.draw.rect(self.screen, self.color, self.rect)
Bullet类继承于pygame.sprite中的Sprite类，此类可以将游戏中的元素进行编组，可以同时操作编组中的所有元素
将子弹存储到编组中
首先在plane_war.py中创建一个编组，用于存储所有有效的子弹，以便能够管理发射出去的子弹；这个编组是pygame.sprite.Group类的一个实例；pygame.sprite.Group类类似于列表，但是提供了有助于开发游戏的额外功能。在主循环中，我们将使用这个编组在屏幕上绘制子弹，以及更新没颗子弹的位置。
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
from settings import Settings
from plane import Plane
import game_func as fg
from pygame.sprite import Group
def run_game():
# 初始化游戏
pygame.init()
# 设置屏幕的分辨率
setting = Settings()
screen = pygame.display.set_mode((setting.screen_width, setting.screen_height)) # 大小为1000px乘以600px
pygame.display.set_caption("飞机大战") # 标题
# 创建一个存储子弹的编组
bullets = Group()
# 创建小飞机
plane = Plane(screen, setting)
# 开始游戏的主循环
while True:
# 不关闭窗口
fg.check_events(plane, setting, screen, bullets)
# 调用小飞机移动的方法
plane.update()
bullets.update()
# 绘制图像
fg.update_screen(screen, setting.bg_img, plane, bullets)
run_game()
开火
通过修改game_func.py中的函数来完成发射子弹的操作
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import sys
from bullet import Bullet
import pygame
def check_keydown_events(event, plane, setting, screen, bullets):
# 捕捉用户按下
if event.key == pygame.K_RIGHT:
# 当用户按下键位时标志位为True
plane.mv_right = True
elif event.key == pygame.K_LEFT:
plane.mv_left = True
elif event.key == pygame.K_SPACE:
# 创建一个子弹，并将其加入到编组bullets中
new_bullet = Bullet(setting, screen, plane)
bullets.add(new_bullet)
def check_keyup_events(event, plane):
# 捕捉用户松开
if event.key == pygame.K_RIGHT:
# 当用户松开键位为false
plane.mv_right = False
elif event.key == pygame.K_LEFT:
plane.mv_left = False
def check_events(plane, setting, screen, bullets):
# 为了防止游戏窗口启动会立马关闭，在其中增加一个游戏循环(无限循环)，
for event in pygame.event.get():
if event.type == pygame.QUIT: # QUIT用户请求程序关闭
sys.exit()
elif event.type == pygame.KEYDOWN:
check_keydown_events(event, plane, setting, screen, bullets)
elif event.type == pygame.KEYUP:
check_keyup_events(event, plane)
def update_screen(screen, bg_img, plane, bullets):
# 更新屏幕的图像
# 每次循环都会重新绘制屏幕
screen.blit(bg_img, [0, 0]) # 绘制图像
# 绘制子弹
for bullet in bullets.sprites():
bullet.draw_bullet() # 绘制子弹
plane.blitme() # 将飞船绘制到屏幕上
# 将完整显示Surface更新到屏幕
pygame.display.flip()
用户按下空格之后会创建一个子弹(一个名为new_bullet的Bullet实例)，并使用
add追加到编组中 方法bullets.sprites返回一个列表，包含了编组中的所有精灵，遍历编组中的精灵，并通过draw_bullet()绘制到屏幕上
效果图：
现在已经完成基本的射击功能了，虽然子弹到达屏幕顶端后消失了，这仅仅是因为pygame无法绘制屏幕外面的东西，这些子弹实际还是存在的，他们的y坐标为负数且越来越少，会继续消耗内存
删除已经消失的子弹
这里通过.copy进行浅拷贝，然后检测子弹是否消失，然后再将其删除
对plane_war.py中的while语句中添加下面这一句
# 删除已经消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
# print(len(bullets)) # 用于测试子弹是否删除
注意：在
fg.update_screen之前进行添加
限制子弹的数量
为了不使这个小游戏跟开挂似得，肯定要限制一下发射子弹的数量，在settings.py中添加一行
# 限制子弹的数量
self.bullet_allowed = 5
在check_keydown_events函数体中增加一个判断即可
简化plane_war.py中的while语句
将发射子弹移步到game_func.py文件中并创建一个update_bullets
def update_bullets(bullets):
# 将编组中的每个子弹调用bullet.update()
bullets.update()
# 删除已经消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
此时的while语句中就4行代码
while True:
fg.check_events(plane, setting, screen, bullets) # 不关闭窗口
plane.update() # 调用小飞机移动的方法
fg.update_bullets(bullets) # 绘制子弹
fg.update_screen(screen, setting.bg_img, plane, bullets) # 绘制图像
小飞机添加完毕的效果
制作飞船
现在小飞机也创建完成了，现在就该创建小飞机的敌人了，同样通过一个类来控制其所有行为，先来看看这个卡哇伊的飞船
目标：创建好非常让其随意移动，可以射杀飞船、当飞船碰到小飞机GAMEOVER，飞船碰到地面也GAMEOVER
创建飞船
创建Spaceship类
创建一个名为spaceship.py的文件来存储Spaceship类
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/4
"""
import pygame
from pygame.sprite import Sprite
class Spaceship(Sprite):
'''表示飞船的类'''
def __init__(self, setting, screen):
super().__init__()
self.screen = screen
self.setting = setting
# 添加飞船图像
self.img = pygame.image.load("./imgs/enemy.png")
# 获取rect属性
self.rect = self.img.get_rect()
# 每个飞船最初都在屏幕左上角附近
self.rect.x = self.rect.width # 飞船图像的左边距等于图像的宽度
self.rect.y = self.rect.height # 飞船图书的上边距等于图像的高度
self.x = float(self.rect.x)
def blitme(self):
# 绘制飞船图像
self.screen.blit(self.img, self.rect)
这里除了位置基本与
Plane类相同
实例化Spaceship类
在plane_war.py中添加Spaceship实例
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
from settings import Settings # 引入settings.py
from plane import Plane
import game_func as fg
from pygame.sprite import Group
from spaceship import Spaceship
def run_game():
# 初始化游戏
pygame.init()
# 设置屏幕的分辨率
setting = Settings()
screen = pygame.display.set_mode((setting.screen_width, setting.screen_height)) # 大小为1000px乘以600px
pygame.display.set_caption("飞机大战") # 标题
# 创建一个存储子弹的编组
bullets = Group()
# 创建小飞机
plane = Plane(screen, setting)
# 创建飞船
spaceship = Spaceship(setting, screen)
# 开始游戏的主循环
while True:
# 不关闭窗口
fg.check_events(plane, setting, screen, bullets)
# 调用小飞机移动的方法
plane.update()
# 绘制子弹
fg.update_bullets(bullets)
# 绘制图像
fg.update_screen(screen, setting.bg_img, plane, bullets, spaceship)
run_game()
这里导入了一下新创建的
Spaceship类，在while循环外创建一个实例，给update_screen传递一个飞船的实例
让飞船出现在屏幕上
修改update_screen函数
def update_screen(screen, bg_img, plane, bullets, spaceship):
# 更新屏幕的图像
# 每次循环都会重新绘制屏幕
screen.blit(bg_img, [0, 0]) # 绘制图像
# 绘制子弹
for bullet in bullets.sprites():
bullet.draw_bullet() # 绘制子弹
plane.blitme() # 将飞船绘制到屏幕上
# 绘制飞船
spaceship.blitme()
# 将完整显示Surface更新到屏幕
pygame.display.flip()
注意其顺序
现在这个好看的小飞船已经出现在了屏幕的左上角
创建一群小飞船
要绘制一群小飞船，需要确定一行能容纳多少个飞船以及要绘制多少行飞船。
确定一行可以容纳多少个飞船
确定一行可以容纳多少个外星人，需要看一下可以用的水平空间有多大。我们的游戏的屏幕宽度在settings.py中的screen.width存储，但需要在屏幕两遍都留下一定的边距，把它设置为小飞船的宽度。由于有两个边距，可以放置飞船的的水平空间为屏幕的宽度减去飞船宽度的2倍
公式为
available_space_x = setting.screen_width - (2 * spaceship_width)
还需要在飞船之间留有一定的宽度，即飞船宽度。所以显示飞船所需要的水平宽度为飞船宽度的2倍；现在确定一行可以容纳多少个飞船
number_spaceship_x = available_space_x / (2 * spaceship_width)
根据这些公式来创建飞船
创建一行飞船
为了创建一行飞船，首先在plane_war.py中创建一个spaceships的空编组用来存储全部的飞船，在调用game_func.py中创建飞船群的函数
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
from settings import Settings # 引入settings.py
from plane import Plane
import game_func as fg
from pygame.sprite import Group
def run_game():
# 初始化游戏
pygame.init()
# 设置屏幕的分辨率
setting = Settings()
screen = pygame.display.set_mode((setting.screen_width, setting.screen_height)) # 大小为1000px乘以600px
pygame.display.set_caption("飞机大战") # 标题
# 创建小飞机
plane = Plane(screen, setting)
# 创建一个存储子弹的编组
bullets = Group()
# 创建飞船编组
spaceships = Group()
# 创建飞船群
fg.create_fleet(setting, screen, spaceships)
# 开始游戏的主循环
while True:
# 不关闭窗口
fg.check_events(plane, setting, screen, bullets)
# 调用小飞机移动的方法
plane.update()
# 绘制子弹
fg.update_bullets(bullets)
# 绘制图像
fg.update_screen(screen, setting.bg_img, plane, bullets, spaceships)
run_game()
改造game.func.py文件并编写创建飞船群函数create_fleet
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import sys
from bullet import Bullet
from spaceship import Spaceship
import pygame
def check_keydown_events(event, plane, setting, screen, bullets):
# 捕捉用户按下
if event.key == pygame.K_RIGHT:
# 当用户按下键位时标志位为True
plane.mv_right = True
elif event.key == pygame.K_LEFT:
plane.mv_left = True
elif event.key == pygame.K_SPACE:
if len(bullets) <= setting.bullet_allowed:
# 创建一个子弹，并将其加入到编组bullets中
new_bullet = Bullet(setting, screen, plane)
bullets.add(new_bullet)
def check_keyup_events(event, plane):
# 捕捉用户松开
if event.key == pygame.K_RIGHT:
# 当用户松开键位为false
plane.mv_right = False
elif event.key == pygame.K_LEFT:
plane.mv_left = False
def check_events(plane, setting, screen, bullets):
# 为了防止游戏窗口启动会立马关闭，在其中增加一个游戏循环(无限循环)，
for event in pygame.event.get():
if event.type == pygame.QUIT: # QUIT用户请求程序关闭
sys.exit()
elif event.type == pygame.KEYDOWN:
check_keydown_events(event, plane, setting, screen, bullets)
elif event.type == pygame.KEYUP:
check_keyup_events(event, plane)
def update_screen(screen, bg_img, plane, bullets, spaceships):
# 更新屏幕的图像
# 每次循环都会重新绘制屏幕
screen.blit(bg_img, [0, 0]) # 绘制图像
# 绘制子弹
for bullet in bullets.sprites():
bullet.draw_bullet() # 绘制子弹
# 绘制飞机
plane.blitme()
# 绘制飞船
for spaceship in spaceships.sprites():
spaceship.blitme()
# 将完整显示Surface更新到屏幕
pygame.display.flip()
def update_bullets(bullets):
# 将编组中的每个子弹调用bullet.update()
bullets.update()
# 删除已经消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
# print(len(bullets)) # 用于测试子弹是否删除
def create_fleet(setting, screen, spaceships): # 创建飞船群函数
# 创建一个飞船
spaceship = Spaceship(setting, screen)
spaceship_width = spaceship.rect.width # 飞船的宽度
# 计算可以容纳多个飞船的宽度
available_space_x = setting.screen_width - (2 * spaceship_width)
number_spaceship_x = int(available_space_x / (2 * spaceship_width)) # 将其转换为整数
for spaceship_number in range(number_spaceship_x):
# 创建一个飞船并加入当前行
spaceship = Spaceship(setting, screen)
spaceship.x = spaceship_width + 2 * spaceship_width * spaceship_number
spaceship.rect.x = spaceship.x
spaceships.add(spaceship)
效果图
因为一个飞船的宽度是占两个的位置，所以最后的空隙有点大，后期反正这个飞船是动起来的，这里先暂时忽略
将create_fleet改写一下，拆分为三个函数体
# 计算每行可以容纳多少个外星人的函数
def get_number_spaceship_x(setting, spaceship_width):
# 计算可以容纳多个飞船的宽度
available_space_x = setting.screen_width - (2 * spaceship_width)
number_spaceship_x = int(available_space_x / (2 * spaceship_width)) # 将其转换为整数
return number_spaceship_x
def create_spaceship(setting, screen, spaceships, spaceship_number):
# 创建一个飞船并加入当前行
spaceship = Spaceship(setting, screen)
spaceship_width = spaceship.rect.width # 飞船的宽度
spaceship.x = spaceship_width + 2 * spaceship_width * spaceship_number
spaceship.rect.x = spaceship.x
spaceships.add(spaceship)
def create_fleet(setting, screen, spaceships):
# 创建一个飞船
spaceship = Spaceship(setting, screen)
number_spaceship_x = get_number_spaceship_x(setting, spaceship.rect.width)
for spaceship_number in range(number_spaceship_x):
create_spaceship(setting, screen, spaceships, spaceship_number)
添加多行小飞船
添加多行就跟一行添加多个是类似的，同样用屏幕的高度减去飞船高度的2倍，这里需要注意的是为了不让小飞机死的很快下面留两倍的高度，还要减去小飞机的高度
available_space_y = setting.screen_heitght - 3 * spaceship_height - plane_height
计算可以放多少行
number_rows = available_space_y / spaceship_height
在game.func.py中进行改写
# 计算每行可以容纳多少个外星人的函数
def get_number_spaceship_x(setting, spaceship_width):
# 计算可以容纳多个飞船的宽度
available_space_x = setting.screen_width - (2 * spaceship_width)
number_spaceship_x = int(available_space_x / (2 * spaceship_width)) # 将其转换为整数
return number_spaceship_x
# 计算可以容纳多少行
def get_number_rows(setting, plane_height, spaceship_height):
available_space_y = setting.screen_height - 3 * spaceship_height - plane_height
print(available_space_y, spaceship_height)
number_rows = int(available_space_y / spaceship_height)
return number_rows
def create_spaceship(setting, screen, spaceships, spaceship_number, number_rows):
# 创建一个飞船并加入当前行
spaceship = Spaceship(setting, screen)
spaceship_width = spaceship.rect.width # 飞船的宽度
spaceship.x = spaceship_width + 2 * spaceship_width * spaceship_number
spaceship.rect.x = spaceship.x
spaceship.rect.y = spaceship.rect.height + 2 * spaceship.rect.height * number_rows
spaceships.add(spaceship)
def create_fleet(setting, screen, spaceships, plane):
# 创建一个飞船
spaceship = Spaceship(setting, screen)
number_spaceship_x = get_number_spaceship_x(setting, spaceship.rect.width)
number_rows = get_number_rows(setting, plane.rect.height, spaceship.rect.height)
for row_number in range(number_rows): # 循环的嵌套
for spaceship_number in range(number_spaceship_x):
create_spaceship(setting, screen, spaceships, spaceship_number, row_number)
这个写的话游戏刚开始我们的飞机就死掉了，现在来做一下修改
首先修改`spaceship.py
# 每个飞船最初都在屏幕左上角附近
self.rect.x = self.rect.width # 飞船图像的左边距等于图像的宽度
self.rect.y = self.rect.height # 飞船图书的上边距等于图像的高度
self.rect.w = self.rect.width
self.rect.h = int(self.rect.height / 2) # 将高度设置为一半
self.x = float(self.rect.x)
由于其高度进行了改变，原来的公式也要进行相应的改变
available_space_y = setting.screen_heitght - 7 * spaceship_height - plane_height # 由之前的3变为7(因为高缩小了一般)
效果图
让飞船动起来
首先在settings.py中增加小飞船相应的设置
# 飞船移动的速度
self.spaceship_speed = 1
# 飞船下降的速度
self.fleet_drop_speed = 10
# 标志位，1表示右移 -1表示左移
self.fleet_direction = 1 # 默认右移动
在spaceship.py中增加判断是否位于边缘的方法和移动的方法
def check_edges(self):
'''如果有飞船位于屏幕边缘，就返回true'''
screen_rect = self.screen.get_rect()
if self.rect.right >= screen_rect.right:
return True
elif self.rect.left <= 0:
return True
def update(self):
"""移动飞船"""
self.x += (self.setting.spaceship_speed * self.setting.fleet_direction)
self.rect.x = self.x
在game_func.py中对spaceship.py方法实例化
def change_fleet_direction(setting, spaceships):
"""将所有飞船下移，并改变方向"""
for spaceship in spaceships.sprites():
spaceship.rect.y += setting.fleet_drop_speed
setting.fleet_direction *= -1 # 如果为1则相乘为-1，如果为-1相乘为1
def check_fleet_edges(setting, spaceships):
"""有飞船到达了边缘应采取的措施"""
for spaceship in spaceships.sprites():
if spaceship.check_edges(): # 如果为true，已经到了边缘，就执行change_fleet_direction
change_fleet_direction(setting, spaceships)
break
def update_spaceships(setting, spaceships):
# 更新飞船的位置
spaceships.update()
# 检测时候又飞船处于边缘，并及时更新
check_fleet_edges(setting, spaceships)
最后在主文件的while语句中增加
fg.update_spaceships(setting, spaceships)
射击飞船
现在子弹和飞船碰撞在一起飞船并不会消失，而是从飞船上穿了过去，并没有达到射击飞船的效果，现在我们将完成这种效果
在这里我们使用game.sprite.groupcollide()方法，此方法检测两个rect是否有元素重叠，并返回一个字典
检测子弹与飞船碰撞
子弹击中飞船后飞船需要马上消失，所以需要在更新子弹的位置后面检测碰撞
方法game.sprite.groupcollide()将每个子弹的rect和每个飞船的rect进行比较，返回一个字典，其中包含了发证碰撞的子弹和飞船。这个字典中每个键都是射中飞船的一颗子弹，相应的值为被击中的飞船
在函数update_bullets()中来检测碰撞
def update_bullets(bullets, spaceships):
# 将编组中的每个子弹调用bullet.update()
bullets.update()
# 删除已经消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
collisions = pygame.sprite.groupcollide(bullets, spaceships, True, True)
修改plane_war.py中的fg.update_bullets为其增加一个参数
fg.update_bullets(bullets, spaceships)
生成新的飞船
当把所有的飞船非射击完毕以后，其不会生成新的飞船
这里需要在update_bullets()之后来判断其长度是否为0，如果为0则调用create_fleet
def update_bullets(bullets, spaceships, setting, screen, plane):
# 将编组中的每个子弹调用bullet.update()
bullets.update()
# 删除已经消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
collisions = pygame.sprite.groupcollide(bullets, spaceships, True, True) # 两个实参true则是为了将其删除
if len(spaceships) == 0:
bullets.empty() # 删除编组中的所有精灵(子弹)
create_fleet(setting, screen, spaceships, plane) # 重新调用生成飞船
修改plane_war.py中的fg.update_bullets为其增加参数
fg.update_bullets(bullets, spaceships, setting, screen, plane)
测试效果
我这里为了测试我将子弹的宽度给修改了自己写的游戏想怎么改就怎么改，游戏意思，哈哈~
总结
游戏结束
当然了，这么玩就失去了游戏的乐趣了，肯定是不可以啊。
现在就增加难度，当飞船碰到飞机、飞船到达地面时就要搞点事情了，不过也不能不给小飞机机会
检测飞船与飞机碰撞
现在我们编写一个新的类GameStats用来跟踪游戏的信息，将其保存为一个新的文件game_stats.py
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/4
"""
class GameStats:
"""跟踪游戏统计信息"""
def __init__(self, setting):
self.setting = setting
self.reset_stats()
def reset_stats(self):
# 初始化在游戏运行期间可能变化的统计信息
self.planes_left = self.setting.plane_limit
在settings中添加一行设置
self.plane_limit = 3 # 小飞机的生命限制
在plane_war.py中创建GameStats的实例
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
from settings import Settings # 引入settings.py
from plane import Plane
import game_func as fg
from pygame.sprite import Group
from game_stats import GameStats
def run_game():
# 初始化游戏
pygame.init()
# 设置屏幕的分辨率
setting = Settings()
screen = pygame.display.set_mode((setting.screen_width, setting.screen_height)) # 大小为1000px乘以600px
pygame.display.set_caption("飞机大战") # 标题
# 创建一个用于存储游戏统计信息的实例
stats = GameStats(setting)
# 创建小飞机
plane = Plane(screen, setting)
# 创建一个存储子弹的编组
bullets = Group()
# 创建飞船编组
spaceships = Group()
# 创建飞船群
fg.create_fleet(setting, screen, spaceships, plane)
# 开始游戏的主循环
while True:
# 不关闭窗口
fg.check_events(plane, setting, screen, bullets)
# 调用小飞机移动的方法
plane.update()
# 更新子弹位置
fg.update_bullets(bullets, spaceships, setting, screen, plane)
# 更新飞船位置
fg.update_spaceships(setting, spaceships, plane, stats, screen, bullets)
# 绘制图像
fg.update_screen(screen, setting.bg_img, plane, bullets, spaceships)
run_game()
因为检测飞船是否与飞机碰撞，所有要对update_spaceships函数进行改写
在添加一个发生碰撞后执行什么从操作的函数plane_ship()
def plane_hit(setting, spaceships, plane, stats, screen, bullets):
"""
有飞船撞击到飞机以后已经数量减1，创建一批新的飞创，并将飞机重新反之到屏幕的原始位置
还将引入time模块的sleep函数实现暂停的效果
"""
stats.planes_left -= 1 # 将planes_left减1
# print(stats.planes_left)
# 清空飞船和子弹的编组
spaceships.empty()
bullets.empty()
# 创建新的飞机和飞船
create_fleet(setting, screen, spaceships, plane)
plane.center_plane()
sleep(1) # 暂停1秒
def update_spaceships(setting, spaceships, plane, stats, screen, bullets):
# 更新飞船的位置
spaceships.update()
# 检测时候又飞船处于边缘，并及时更新
check_fleet_edges(setting, spaceships)
# 检测飞船与飞机直接的碰撞
'''
pygame.sprite.spritecollideany方法
* 接受两个参数，一个精灵和一个编组，
* 检测编组中的成员是否与碰撞，如果检测到碰撞则停止遍历编组
* 如果没有发生碰撞则返回None
'''
game_over = pygame.sprite.spritecollideany(plane, spaceships)
if game_over:
plane_hit(setting, spaceships, plane, stats, screen, bullets)
注意：在一开始要导入time模块的sleep函数
最后在plane.py文件中添加center.plane方法，来实现居中
def center_plane(self):
"""让小飞机居中"""
self.center - self.screen_rect.centerx
这里并没有对小飞机进行重新的绘制，仅仅是将其重新放回中间
检测飞船到达屏幕底部
将创建一个新的函数来完成这项任务，名为check_spaceship_bottom()
def check_spaceship_bottom(setting, spaceships, plane, stats, screen, bullets):
# 检测是否有飞船触碰到底部
screen_rect = screen.get_rect()
for spaceship in spaceships.sprites():
if spaceship.rect.bottom >= screen_rect.bottom:
# 跟飞船碰撞一样处理
plane_hit(setting, spaceships, plane, stats, screen, bullets)
在update_spaceships函数体中调用此函数
check_spaceship_bottom(setting, spaceships, plane, stats, screen, bullets)
结束游戏
现在游戏还是不会结束的，planes_left只会无限的减少，这里在GameStats中添加一个标志位game_active，用来记录飞船的数量是否为0
self.game_active = True
修改plane_hit()的代码
def plane_hit(setting, spaceships, plane, stats, screen, bullets):
"""
有飞船撞击到飞机以后已经数量减1，创建一批新的飞创，并将飞机重新反之到屏幕的原始位置
还将引入time模块的sleep函数实现暂停的效果
"""
if stats.planes_left > 0:
stats.planes_left -= 1 # 将planes_left减1
# print(stats.planes_left)
# 清空飞船和子弹的编组
spaceships.empty()
bullets.empty()
# 创建新的飞机和飞船
create_fleet(setting, screen, spaceships, plane)
plane.center_plane()
sleep(1) # 暂停1秒
else:
stats.game_active = False
这里游戏也不会真正的结束，这里暂时空着，下面为其补全。想要退出的话在else子句中调用
sys.exit()即可
完善项目
现在这个小游戏的基本雏形已经出来了，但是还称不上一个完整的游戏，现在为其增加一个开始按钮，用于启动游戏和结束游戏；随着游戏时间的增长游戏难度也将进行增长；在增加一个记分系统。
play按钮
我们的目的是让游戏一开始点击play按钮可以开始游戏，游戏结束时在点击play按钮又能开始游戏
所以我们现在需要将GameStats中的标志位game_active为False，让游戏默认为不活动状态
self.game_active = False
只有这个样子才能完成play按钮才能完成他想完成的工作
由于pygame中没有创建按钮的方法，需要创建一个Button类，用于创建带标签的实心矩形。
现在创建一个button.py的文件
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/5
"""
import pygame.font # 导入pygame.font模块，可以使屏幕渲染在屏幕上
class Button:
def __init__(self, setting, screen, msg):
"""初始化按钮的属性"""
self.screen = screen
self.screen_rect = screen.get_rect()
# 设置按钮的大小
self.width = 200
self.height = 20
# 设置按钮的颜色
self.button_color = (0, 255, 0)
# 设置文本的颜色
self.text_color = (200, 200, 200)
# 设置字体的大小
self.font = pygame.font.SysFon("SimHei", 48) # 字体为黑体大小为48像素
# 创建按钮的rect对象
self.rect = pygame.Rect(0, 0, self.width, self.height)
# 使按钮居中
self.rect.center = self.screen_rect.center
# 按钮的标签只需要创建一次
self.prep_msg(msg)
def prep_mas(self, msg):
# msg渲染为图像
"""
font.reder方法是将msg中的文本转换为图像
* 参数True是开启抗锯齿模式
* self.text_color是文本的颜色
* self.button_color是背景颜色
"""
self.msg_image = self.font.reder(msg, True, self.text_color, self.button_color)
# 使其在按钮上居中
self.msg_image_rect = self.msg_image.get_rect()
self.msg_image_rect.center = self.rect.center
def draw_button(self):
# 绘制按钮
self.screen.fill(self.button_color, self.rect) # 用一个颜色填充文本
self.screen.blit(self.msg_imagem, self.msg_image_rect) # 绘制文本
现在将按钮绘制出来，并设置在非活动状态下显示按钮
在plane_war.py中添加Button类的实例化，并将其作为参数传递给update_screen()以便可以在屏幕更新时显示按钮
...
from button import Button
def run_game():
...
pygame.display.set_caption("飞机大战") # 标题
# 创建play按钮
play_button = Button(setting, screen, "Play")
...
# 开始游戏的主循环
while True:
...
# 绘制图像
fg.update_screen(screen, setting.bg_img, plane, bullets, spaceships, stats, play_button)
run_game()
现在修改一下update_screen()函数
def update_screen(screen, bg_img, plane, bullets, spaceships, stats, play_button):
# 更新屏幕的图像
# 每次循环都会重新绘制屏幕
screen.blit(bg_img, [0, 0]) # 绘制图像
# 绘制子弹
for bullet in bullets.sprites():
bullet.draw_bullet() # 绘制子弹
# 绘制飞机
plane.blitme()
for spaceship in spaceships.sprites():
spaceship.blitme()
# 如果游戏处于非活动状态，绘制Play按钮
if not stats.game_active:
play_button.draw_button()
# 将完整显示Surface更新到屏幕
pygame.display.flip()
开始游戏
现在按钮出来了，但是没有任何功能，现在来完成这个按钮的功能
这里需要检测鼠标按下的事件来做出相应的操作，修改check_events()函数，为其增加两个参数stats, **play_butto然后做出相应的操作
def check_events(plane, setting, screen, bullets, stats, play_button):
# 为了防止游戏窗口启动会立马关闭，在其中增加一个游戏循环(无限循环)，
for event in pygame.event.get():
if event.type == pygame.QUIT: # QUIT用户请求程序关闭
sys.exit()
elif event.type == pygame.KEYDOWN:
check_keydown_events(event, plane, setting, screen, bullets)
elif event.type == pygame.KEYUP:
check_keyup_events(event, plane)
elif event.type == pygame.MOUSEBUTTONDOWN: # 检测MOUSEBUTTONDOWN事件
mouse_x, mouse_y = pygame.mouse.get_pos() # 返回一个元组，包含鼠标单击时的坐标
check_play_button(stats, play_button, mouse_x, mouse_y) # 调用check_play_button
def check_play_button(stats, play_button, mouse_x, mouse_y):
# 用于检测鼠标的坐标是否与按钮相重合
# 玩家单机play按钮时开始游戏
if play_button.rect.collidepoint(mouse_x, mouse_y): # collidepoint检测单击的位置是否在按钮的rect内
stats.game_active = True
修改一下循环中的check_events()函数将参数传递进去
fg.check_events(plane, setting, screen, bullets, stats, play_button)
效果图
如果3次机会用完了这个play按钮还是会出来
现在单机play按钮对于游戏来说没有任何影响，下面对这个功能进行完善
重新游戏
现在完成当玩家点击play按钮都会重置游戏(重置游戏的活动状态和飞机的次数)，删除所有的子弹和飞船，创建一批新的飞船，并让飞船居中
def check_events(plane, setting, screen, bullets, stats, play_button, spaceships):
# 为了防止游戏窗口启动会立马关闭，在其中增加一个游戏循环(无限循环)，
for event in pygame.event.get():
if event.type == pygame.QUIT: # QUIT用户请求程序关闭
sys.exit()
elif event.type == pygame.KEYDOWN:
check_keydown_events(event, plane, setting, screen, bullets)
elif event.type == pygame.KEYUP:
check_keyup_events(event, plane)
elif event.type == pygame.MOUSEBUTTONDOWN: # 检测MOUSEBUTTONDOWN事件
mouse_x, mouse_y = pygame.mouse.get_pos() # 返回一个元组，包含鼠标单击时的坐标
check_play_button(plane, setting, screen, bullets, stats, play_button, mouse_x, mouse_y, spaceships)
def check_play_button(plane, setting, screen, bullets, stats, play_button, mouse_x, mouse_y, spaceships):
# 玩家单机play按钮时开始游戏
if play_button.rect.collidepoint(mouse_x, mouse_y): # collidepoint检测单击的位置是否在按钮的rect内
stats.game_active = True
# 重置游戏统计信息
stats.reset_stats()
# 清空飞船列表和子弹列表
spaceships.empty()
bullets.empty()
# 让飞机居中
plane.center_plane()
在主循环中添加相应的参数
fg.check_events(plane, setting, screen, bullets, stats, play_button, spaceships)
解决一个bug
现在游戏中有一个小bug，不管游戏开没开始，单击中间的按钮区域都会重新开始，修改这个bug，可以让游戏在stats.game_active值为False时才开始，还有一个问题就是游戏开始以后光标没有任何的作用，这个时候可以将光标隐藏
修改check_play_button()函数
def check_play_button(plane, setting, screen, bullets, stats, play_button, mouse_x, mouse_y, spaceships):
# 玩家单机play按钮时开始游戏
# collidepoint检测单击的位置是否在按钮的rect内
button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
if button_clicked and not stats.game_active: # 当stats.game_active的值为False时，取反才会执行
# 隐藏光标
pygame.mouse.set_visible(False)
# 游戏状态
stats.game_active = True
# 重置游戏统计信息
stats.reset_stats()
# 清空飞船列表和子弹列表
spaceships.empty()
bullets.empty()
# 让飞机居中
plane.center_plane()
当然，光标隐藏了就要需要显示，在plane_hit()中stats.game_active一起修改，当游戏状态位False时，就要需要鼠标，所以在其下面修改为True
def plane_hit(setting, spaceships, plane, stats, screen, bullets):
"""
有飞船撞击到飞机以后已经数量减1，创建一批新的飞创，并将飞机重新反之到屏幕的原始位置
还将引入time模块的sleep函数实现暂停的效果
"""
if stats.planes_left > 0:
stats.planes_left -= 1 # 将planes_left减1
# print(stats.planes_left)
# 清空飞船和子弹的编组
spaceships.empty()
bullets.empty()
# 创建新的飞机和飞船
create_fleet(setting, screen, spaceships, plane)
plane.center_plane()
sleep(1) # 暂停1秒
else:
stats.game_active = False
# 将光标设置为显示
pygame.mouse.set_visible(True)
提高等级
现在这个游戏虽然有了死亡，但是 这种游戏难度只有想玩，还是不会死掉的，现在要随着消灭的飞船的数量来增加游戏的难度
修改速度的设置
现在重新组织一下Settings类，将游戏中的这还是分为静态和动态两类，在添加一个提高速度的方法
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
class Settings:
"""存储飞机大战的所有设置"""
def __init__(self):
# 屏幕设置
self.screen_width = 1000
self.screen_height = 600
self.bg_img = pygame.image.load("./imgs/bg_img.png")
#小飞机设置
# 小飞机的生命限制
self.plane_limit = 3
# 子弹的设置
self.bullet_width = 3 # 子弹的宽
self.bullet_height = 15 # 子弹的高
self.bullet_color = 190, 190, 190 # 子弹的颜色
# 限制子弹的数量
self.bullet_allowed = 5
# 飞船下降的速度
self.fleet_drop_speed = 10
# 以什么样的速度加快游戏节奏
self.speedup_scale = 1.2
self.initialize_dynamic_settings()
def initialize_dynamic_settings(self):
#小飞机设置
# 小飞机的移动速度
self.plane_speed = 2.5
# 子弹的设置
self.bullet_speed = 3 # 速度
# 飞船移动的速度
self.spaceship_speed = 2
# 标志位，1表示右移 -1表示左移
self.fleet_direction = 1 # 默认右移动
def increase_speed(self):
"""提高游戏节奏"""
self.plane_speed *= self.speedup_scale
self.bullet_speed *= self.speedup_scale
self.spaceship_speed *= self.speedup_scale
这里设置好了，现在我们想要在新的一批飞船来临之前来增加游戏的节奏，在创建新的一批飞船
def update_bullets(bullets, spaceships, setting, screen, plane):
# 将编组中的每个子弹调用bullet.update()
bullets.update()
# 删除已经消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
collisions = pygame.sprite.groupcollide(bullets, spaceships, True, True) # 两个实参true则是为了将其删除
if len(spaceships) == 0:
bullets.empty() # 删除编组中的所有精灵(子弹)
# 加快游戏节奏
setting.increase_speed()
create_fleet(setting, screen, spaceships, plane) # 重新调用生成飞船
通过修改
update_bullets，在飞船数量为0的时候进行加速
修改plane_war.py
这时不论game_active的值为False还是True一开始都会创建一些图像，这里通过if语句来判断是否创建
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/3
"""
import pygame
from settings import Settings # 引入settings.py
from plane import Plane
import game_func as fg
from pygame.sprite import Group
from game_stats import GameStats
from button import Button
def run_game():
# 初始化游戏
pygame.init()
# 设置屏幕的分辨率
setting = Settings()
screen = pygame.display.set_mode((setting.screen_width, setting.screen_height)) # 大小为1000px乘以600px
pygame.display.set_caption("飞机大战") # 标题
# 创建play按钮
play_button = Button(setting, screen, "Play")
# 创建一个用于存储游戏统计信息的实例
stats = GameStats(setting)
# 创建小飞机
plane = Plane(screen, setting)
# 创建一个存储子弹的编组
bullets = Group()
# 创建飞船编组
spaceships = Group()
# 开始游戏的主循环
while True:
# 不关闭窗口
fg.check_events(plane, setting, screen, bullets, stats, play_button, spaceships)
if stats.game_active: # 根据游戏状态来判断是否需要创建其图像
# 调用小飞机移动的方法
plane.update()
# 更新子弹位置
fg.update_bullets(bullets, spaceships, setting, screen, plane)
# 更新飞船位置
fg.update_spaceships(setting, spaceships, plane, stats, screen, bullets)
# 绘制图像
fg.update_screen(screen, setting.bg_img, plane, bullets, spaceships, stats, play_button)
run_game()
重置游戏速度
目前来说每一次游戏开始都是接着上一次的速度开始增加的，这肯定是不可以的，现在修改当玩家点击play按钮是，速度复原
修改check_play_button()函数
def check_play_button(plane, setting, screen, bullets, stats, play_button, mouse_x, mouse_y, spaceships):
# 玩家单机play按钮时开始游戏
# collidepoint检测单击的位置是否在按钮的rect内
button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
if button_clicked and not stats.game_active: # 当stats.game_active的值为False时，取反才会执行
# 重置游戏设置
setting.initialize_dynamic_settings()
# 隐藏光标
pygame.mouse.set_visible(False)
# 游戏状态
stats.game_active = True
# 重置游戏统计信息
stats.reset_stats()
# 清空飞船列表和子弹列表
spaceships.empty()
bullets.empty()
# 让飞机居中
plane.center_plane()
分数系统
现在完成一个跟踪玩家的事情情况来展示得分、最高分、当前的等级、余下的飞船数量
得分是游戏的一项统计信息，所以我们在GamaStats中添加一个socre属性
class GameStats:
...
def reset_stats(self):
# 初始化在游戏运行期间可能变化的统计信息
self.planes_left = self.setting.plane_limit
# 统计得分
self.score = 0
显示得分
为了在屏幕上显示得分，我们先创建一个类Scoreboard。这个类不光显示得分，最高分、飞船数量以及等级都会在此展示
新建一个scoreboard.py来存储这个新类
"""
-*- coding:uft-8 -*-
author: 小甜
date:2020/6/5
"""
import pygame.font
class Scoreboard:
"""显示得分信息的类"""
def __init__(self, setting, screen, stats):
"""初始化得分涉及到的属性"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.stats = stats
# 显示得分的字体设置
# 设置文本的颜色
self.text_color = (20, 20, 20)
# 设置字体的大小
self.font = pygame.font.SysFont("SimHei", 40) # 字体为黑体大小为40像素
# 初始化得分图像
self.prep_score()
def prep_score(self):
"""将得分转换为图像"""
score_str = str(self.stats.score)
self.score_image = self.font.render(score_str, True, self.text_color)
# 将得分放到屏幕的右上角
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20 # 与右边差20 像素
self.score_rect.top = 20 # 与顶部差20像素
def show_score(self):
"""在屏幕上显示得分"""
self.screen.blit(self.score_image, self.score_rect)
现在创建类的实例化
...
from scoreboard import Scoreboard
def run_game():
...
# 创建一个用于存储游戏统计信息的实例
stats = GameStats(setting)
# 创建记分的实例
score_board = Scoreboard(setting, screen, stats)
...
while True:
...
fg.update_screen(screen, setting.bg_img, plane, bullets, spaceships, stats, play_button, score_board)
run_game()
创建
Scoreboard类的实例化，并在update_screen()传入score_board让其能够在屏幕显示得分
在update_screen调用show_score()使其在屏幕上绘制出来
def update_screen(screen, bg_img, plane, bullets, spaceships, stats, play_button, score_board):
...
# 显示得分
score_board.show_score()
...
# 将完整显示Surface更新到屏幕
pygame.display.flip()
效果图
更新得分
首先设置击落一个飞船给多少分，在settings.py中的initialize_dynamic_settings()方法添加一个属性
# 击落一个飞船的得分
self.spaceship_points = 10
在子弹与飞船碰撞之后更新得分，这里修改update_bullets()函数
def update_bullets(bullets, spaceships, setting, screen, plane, stats, score_board):
# 将编组中的每个子弹调用bullet.update()
bullets.update()
# 删除已经消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
collisions = pygame.sprite.groupcollide(bullets, spaceships, True, True) # 两个实参true则是为了将其删除
"""这个字典中的键是打中小飞船的子弹，值则为一个列表，其中包含了所有被打中的值"""
if collisions: # 当发生碰撞，会有有返回值，才会为True
for spaceship in collisions.values():
"""遍历这个字典，确保每个外星人的点数都计入得分"""
stats.score += setting.spaceship_points * len(spaceship) # 发生碰撞加分
"""因为子弹的值是一个列表，所有这里每次计算一下列表的长度来进行加分"""
score_board.prep_score() # 并绘制在屏幕上
if len(spaceships) == 0:
bullets.empty() # 删除编组中的所有精灵(子弹)
# 加快游戏节奏
setting.increase_speed()
create_fleet(setting, screen, spaceships, plane) # 重新调用生成飞船
在主循环中为其增加实参
fg.update_bullets(bullets, spaceships, setting, screen, plane, stats, score_board)
提高游戏分数
现在我们的基本打怪给分已经完成了，但是随着游戏难度的增长，打怪的得分并不会随着增长，这里类似于难度的设置也增加几行代码让其完成这个功能
在settings.py中的__init__添加l两行
...
class Settings:
"""存储飞机大战的所有设置"""
def __init__(self):
...
# 提高分数的速度
self.score_scale = 1.5
self.initialize_dynamic_settings()
def initialize_dynamic_settings(self):
...
def increase_speed(self):
...
# 提高飞船的分数
self.spaceship_points = int(self.spaceship_points * self.score_scale)
最高得分
为了超越自己，肯定会有一个最高得分系统，在GameStats类中的__init__方法中添加一行
# 最高得分
self.high_score = 0
现在来修改一下Scoreboard类以便显示最高分
...
class Scoreboard:
"""显示得分信息的类"""
def __init__(self, setting, screen, stats):
...
self.font = pygame.font.SysFont("SimHei", 40) # 字体为黑体大小为40像素
# 初始化得分图像
self.prep_score()
# 初始化最高分图像
self.prep_high_score()
def prep_score(self):
...
def prep_high_score(self):
"""将得分转换为图像"""
high_score_str = self.stats.high_score
self.high_score_image = self.font.render(high_score_str, True, self.text_color)
# 将得分放到屏幕的顶部中间
self.score_rect = self.score_image.get_rect()
self.score_rect.centerx = self.screen_rect.centerx
self.score_rect.top = 10
def show_score(self):
"""在屏幕上显示得分"""
self.screen.blit(self.score_image, self.score_rect)
# 显示最高分
self.screen.blit(self.high_score_image, self.high_score_rect)
在game_func.py中添加一个函数，用于计算当前的分数是否大于最高分，并在update_bullets中进行调用
...
def update_bullets(bullets, spaceships, setting, screen, plane, stats, score_board):
...
if collisions: # 当发生碰撞，会有有返回值，才会为True
for spaceship in collisions.values():
"""遍历这个字典，确保每个外星人的点数都计入得分"""
stats.score += setting.spaceship_points * len(spaceship) # 发生碰撞加分
"""因为子弹的值是一个列表，所有这里每次计算一下列表的长度来进行加分"""
score_board.prep_score() # 并绘制在屏幕上
check_high_score(stats, score_board)
if ...
...
def check_high_score(stats, score_board):
"""用于检测是否产生最高分"""
if stats.score > stats.high_score:
stats.high_score = stats.score # 如果的得分大于最高分，则值赋给最高分
score_board.prep_high_score()
甜甜有话说
终于把这个小项目给完成了，这里用的pygame模块一边学一边这就很难哎，反正最后也弄出来