飞机大战实操

1.4.1项目准备
1.4.1.1确定模块pygame是否安装成功
安装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的版本)
安装pygame模块

$ sudo pip3 install pygame
1
验证是否安装成功(安装成功会有自带的游戏界面显示)

$ python3 -m pygame.examples.aliens
1
1.4.1.2项目准备
新建飞机大战项目
新建一个dt_01_pygame入门.py
导入游戏素材图片
1.4.2游戏窗口和绘制图像
1.4.2.1游戏窗口
1.4.2.1.1游戏的初始化和退出
在使用pygame提供的所有功能之前需要调用pygame的init方法，在游戏结束前要调用一下quit方法

方法 说明
pygame.init() 导入并初始化所有的pygame模块，使用其它模块之前必须先调用init方法
pygame.quit() 卸载所有的pygame模块，在游戏结束之前调用(及时释放内存中的空间)
1.4.2.1.2pygame.Rect描述矩形区域
在游戏中，所有可见元素都是以矩形区域来描述位置的，要描述一个矩形区域有四个要素(x, y)(width, height)，分别表示横坐标、纵坐标、矩形的宽度、矩形的高度

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

Rect(x, y, width, height) # 创建对象
1
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
2
3
4
1.4.2.1.3创建游戏窗口和游戏循环
创建游戏主窗口和游戏循环

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()方法的返回值必须要有变量进行记录，因为后期所有的操作都是基于这个返回结果的

1
2
3
4
游戏循环防止窗口一闪后立刻退出

代码实例：

import pygame
pygame.init()
main_windows = pygame.display.set_mode((100,100)) # 这里(100,100)之前不能写参数resolution，直接写元祖表示窗口的宽度和高度就好

无限循环防止窗口一闪而过

while True:
pass
pygame.quit()
1
2
3
4
5
6
7
1.4.2.2绘制图像
1.4.2.2.1绘制图像的三个步骤
将图像加载到内存

使用pygame.image.load()加载图像的数据
使用屏幕对象，调用blit方法将加载的图像绘制到指定的位置

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

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

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

在游戏中每一次调用update()方法产生的效果叫做帧，一般在电脑上每秒绘制60次(也就是每秒调用60次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需要添加此行代码才会更新图片，否则图片不会被插入显示

上一行代码不需要每次添加图片都写一次，只需要在最后一个图片插入后写一次即可

无限循环防止窗口一闪而过

while True:
pass

pygame.quit()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1.4.3游戏循环和键盘事件
1.4.3.1游戏循环
1.4.3.1.1相关概念介绍
游戏循环意味着游戏的正式开始
在游戏开发中通常将游戏分为两个部分：游戏初始化(设置游戏窗口、绘制图像初始位置、设置游戏时钟)和游戏循环(设置刷新频率、检测用户交互、更新所有图像的位置、更新屏幕显示)
1.4.3.1.2利用时钟设置游戏循环的刷新帧率
创建时钟对象：clock = pygame.time.Clock()

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

代码实例

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1.4.3.1.3英雄动画效果实现
在游戏循环中每一次调用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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
1.4.3.2事件监听
1.4.3.2.1基本概念和相关方法
事件event：

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

在游戏循环中判断用户的具体的操作
代码实现

在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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
1.4.4精灵和精灵组
1.4.4.1基本概念
为了简化开发步骤，pygame提供了两个类：pygame.sprite.Sprite和pygame.sprite.Group，其中pygame.sprite.Sprite存储了图像数据image和位置rect的对象

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

精灵和精灵组

精灵(需要派生子类)
image：记录图像数据；rect：记录在屏幕上的位置
update(*args)：更新精灵位置；kill()：从所有组中删除
精灵组
init(self, *精灵)：add(*sprites)：向组中增加精灵；sprites()：返回所有精灵列表；update(*args)：让组中所有精灵调用update方法；draw(Surface)：将组中所有精灵的image绘制到Surface的rect位置
1.4.4.2派生精灵子类
代码实现

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
说明：如果一个类的父类不是object(这里的父类事名义上的父类)，在重写父类的__init__方法时，要使用super()主动调用父类的__init__方法，否则子类将无法使用父类__init__中的方法和属性

1.4.4.3设置敌机精灵组
精灵类

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
实现代码

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
1.4.5框架搭建
1.4.5.1明确类的相关设计
设置一个主程序plan_main用以实现游戏；设置一个程序plan_sprites实现其它功能

plan_main

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

plan_sprites
封装游戏中所有需要的精灵子类
提供游戏的相关工具
设计一个主游戏类PlanGame类，实现以下功能

PlanGame
screen;clock;精灵组或精灵
init(self):游戏初始化;__create_sptites(self):创建精灵;start_game(self):游戏循环;__event_handler(self):事件监听;__check_collide(self):碰撞检测;__update_sprites(self):更新精灵组;game_over():游戏结束
游戏初始化方法__init()功能实现

游戏初始化
设置游戏窗口
创建游戏时钟
创建精灵、精灵组
游戏循环方法start_game()功能实现

游戏循环
设置刷新频率
事件监听
碰撞检测
更新/绘制精灵组
更新屏幕显示
1.4.5.2常量的定义
在python中没有严格意义上的常量，只是通过命名的约束(通常所有字母都是大写就看作为常量)，常量的单词之间用下划线连接；在实际开发中为防止某一个值的需求一直变化导致需要修改程序中所有的原先初值，可以将这个值设置为一个常量，当需求变化时只需要修改改常量的值即可而不需要修改原先所有的值
1.4.6背景图像
1.4.6.1实现背景图像的交替滚动
使用两张图像来实现背景图像的交替滚动

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

Background
init(self, is_alt):update(self)
1.4.7敌人飞机
1.4.8英雄飞机
1.4.8.1针对键盘按键的捕获
方式一：判断event.type == pygame.KEYDOWN

实例：
if event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT:
print(“向右移动”)

event不是模块而是获取到的监听事件，event.key == pygame.K_RIGHT是用来判断用户的按键是否是右键，这种方法如果一直按键不放是只会识别为只按下了一次键而不会识别为连续按下多次键

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

实例：
keys_pressed = pygame.key.get_pressed()
if keys_pressed[pygame.K_RIGHT]: # 这里的pygame.K_RIGHT是元祖的索引
print(“向右移动”)

这种方法如果一直按键不放会识别为连续按下多次键

1
2
3
4
5
1.4.9发射子弹以及碰撞检测
1.4.9.1定时器使用套路
第一步：定义计时器常量eventid(一般用USEREVENT来表示第一个事件，后面如果要增加事件就+1即可)

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

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

代码实例：

第一步：定义计时器常量

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
2
3
4
5
6
7
8
9
1.4.9.2碰撞检测
pygame的两种实现碰撞的方法

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

两个精灵组的所有精灵的碰撞检测
groupcollide(group1, group2, dokill1, dokill2, collided = None) --> Sprite_dict

kokill1和group1有关，kokill2和group2有关；如果kokill1设置为True则如果group1发生碰撞则会将group1销毁

collided参数用来计算碰撞的回调函数，如果没有指定则每个精灵必须有一个rect属性

1
2
3
4
第二种方法：pygame.sprite.spritecollide()

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

当dokill设置为True时，如果sprite发生碰撞则sprite会被销毁，返回的是精灵组中和精灵发生碰撞的精灵列表

1
2
1.4.10完整代码实现
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()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
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("子弹被销毁..自定义目录标题)

飞机大战项目实战

欢迎使用Markdown编辑器

你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

新的改变

我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：

1. 全新的界面设计 ，将会带来全新的写作体验；
2. 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
3. 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
4. 全新的 KaTeX数学公式 语法；
5. 增加了支持甘特图的mermaid语法¹ 功能；
6. 增加了 多屏幕编辑 Markdown文章功能；
7. 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
8. 增加了 检查列表 功能。

功能快捷键

撤销：Ctrl/Command + Z
重做：Ctrl/Command + Y
加粗：Ctrl/Command + B
斜体：Ctrl/Command + I
标题：Ctrl/Command + Shift + H
无序列表：Ctrl/Command + Shift + U
有序列表：Ctrl/

---

1. mermaid语法说明 ↩︎