Python小游戏-《外星人入侵》

《外星人入侵》游戏

游戏介绍

在游戏中,玩家控制着一艘最初出现在屏幕底部中央的飞船,玩家可以使用键盘中的左右键控制飞船的左右移动,还可以用空格键进行射击。

游戏开始时,一群外星人出现在天空中,他们在屏幕中往下移动,玩家的任务就是射杀这些外星人。玩家将所有外星人击杀后,玩家等级升一级并且在屏幕上方将出现新的一群外星人,他们的移动速度更快。玩家每次击杀一个外星人都记录一个分数,游戏结束后记录每局游戏的最高分,每次游戏开始时将最高分显示在屏幕中央。

只要有外星人撞到了玩家的飞船或者到达了底部,玩家就损失一艘飞船,玩家损失3艘飞船后,游戏结束!

分析

  • 需要一个游戏窗口,显示飞船图片,显示外星人图片,显示分数,等级
  • 控制飞船:左右移动、空格射击
  • 控制外星人:下移速度
  • 控制子弹:子弹的速度、方向
  • 记录玩家数据:等级、最高分、当前分、剩余的飞船数

使用工具

  • Pygame:用于等任务绘制图像
  • Sublime Text 3:文本编辑器,用于开发超级爽!

工具的安装

1
2
# 安装 Pygame 
python -m pip install --user pygame-1.9.2a0-cp35-none-win32.whl

编码前的分析

  • 系统的设置管理:屏幕参数的初始化、飞船数据的初始化、外星人数据的初始化、子弹数据的初始化

编码【直接看GitHub源码地址】————————————-

  • 程序入口

每个程序都有程序的入口,Python 游戏也不例外,以下是程序的入口文件aliens_invasion.py

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
import sys
import pygame
import game_functions as gf

from settings import Settings
from ship import Ship
from alien import Alien
from pygame.sprite import Group
from game_stats import GameStats
from button import Button
from scoreboard import Scoreboard

def run_game():
# 初始化游戏并创建屏幕对象
pygame.init()
ai_settings = Settings() ;

# 设置屏幕参数
screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))

# 设置游戏名称
pygame.display.set_caption("Alien Invasion")

# 创建paly按钮
play_button = Button(ai_settings, screen, "Play")

# 在屏幕上创建飞船
ship = Ship(ai_settings, screen)

# 将子弹存储在一个编组中
bullets = Group()
# 将外星人存储在一个编组中
aliens = Group()

# 创建外星人群
gf.create_fleet(ai_settings,screen,ship,aliens)

# 设置背景色
bg_color = (ai_settings.bg_color)

# 创建一个外星人实例
alien = Alien(ai_settings, screen)

# 创建一个用于存储游戏统计的实例
stats = GameStats(ai_settings)

# 创建记分牌
sb = Scoreboard(ai_settings, screen, stats)

# 开始游戏的主要循环
while True:
# 监听键盘和鼠标事件
gf.check_events(ai_settings, screen, stats, sb, play_button, ship, aliens, bullets)

# 根据游戏状态来刷新屏幕里面的内容,游戏有开始和结束状态
if stats.game_active:
# 刷新飞船的位置
ship.update()
# 更新子弹的位置
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens, bullets)
# 更新外星人的位置
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens, bullets)

# 刷新屏幕
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets, play_button)

# 函数调用
run_game()
  • 设置管理

总的数据管理中心,便于数据的控制,代码如下setting.py

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
class Settings():
"""
存储《外星人入侵》的所有的设置的类
1. 屏幕设置
2. 飞船设置
3. 子弹设置
4. 外星人设置
5. 游戏初始化时参数的默认设置
6. 游戏升级后的参数修改设置
"""
def __init__(self):
""" 初始化游戏的设置 """
# 屏幕设置
self.screen_width = 1200
self.screen_height = 600
self.bg_color = (230, 230, 230)

# 飞船的设置
# 一开始玩家拥有的飞船数量
self.ship_limit = 3

# 子弹的设置
self.bullet_width = 3
self.bullet_hight = 15
self.bullet_color = 60, 60, 60

# 子弹的默认数量(一次只能发射的个数)
self.bullets_allowed = 3

# 外星人的设置
self.fleet_drop_speed = 20

# 以什么样的速度加快游戏节奏
self.speedup_scale = 1.1
# 击杀外星人点数的提高速度
self.score_scale = 1.5

self.initialize_dynamic_settings()

def initialize_dynamic_settings(self):
"""初始化游戏进行而变化的设置"""
# 飞船的移动像素为1.5一次
self.ship_speed_factor = 1.5
# 子道的移动像素为3一次
self.bullet_speed_factor = 3
# 外星人的移动像素为1一次
self.alien_speed_factor = 1

# fleet_direction 为 1 表示向右移,为-1表示向左移
self.fleet_direction = 1

# 计分
self.alien_points = 50

def increase_speed(self):
"""提高速度设置和外星人点数"""
# 提高飞船的速度
self.ship_speed_factor *= self.speedup_scale
# 提高子弹的速度
self.bullet_speed_factor *= self.speedup_scale
# 提高外星人的速度
self.alien_speed_factor *= self.speedup_scale
# 提高击杀一只外星人分数的速度
self.alien_points = int(self.alien_points * self.score_scale)
  • 各个对象

游戏中需要有飞船对象ship.py,外星人对象alien.py,子弹对象bullet.py,UI显示对象scoreboard.py,游戏数据统计对象game_stats.py,开始游戏按钮对象button.py

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
# 飞船对象
import pygame
from pygame.sprite import Sprite

class Ship(Sprite):
"""
飞船类
1. 飞船数据初始化
2. 显示飞船
3. 更新飞船移动后的位置
"""
def __init__(self, ai_settings, screen):
""" 初始化飞行并设置其初始位置 """
super(Ship, self).__init__()
self.screen = screen
self.ai_settings = ai_settings

# 加载飞船图像并获取其外界矩形
self.image = pygame.image.load('images/ship.bmp')
self.rect = self.image.get_rect()
self.screen_rect = screen.get_rect()

# 将每艘飞船放在屏幕底部中央
self.rect.centerx = self.screen_rect.centerx
self.rect.bottom = self.screen_rect.bottom

# 在飞船的属性center中存储小数值
self.center = float(self.rect.centerx)

# 移动标志
self.moving_right = False
self.moving_left = False

def update(self):
"""根据移动标志调整飞船的位置"""
# 更新飞船的center值,而不是rect. 不让飞船移出屏幕边界
if self.moving_right and self.rect.right < self.screen_rect.right:
self.center += self.ai_settings.ship_speed_factor
if self.moving_left and self.rect.left > 0:
self.center -= self.ai_settings.ship_speed_factor

# 根据self.center更新rect对象
self.rect.centerx = self.center

def blitme(self):
""" 在指定位置绘制飞船"""
self.screen.blit(self.image, self.rect)

def center_ship(self):
"""让飞船在屏幕上居中"""
self.center = self.screen_rect.centerx
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
# 外星人对象
import pygame
from pygame.sprite import Sprite

class Alien(Sprite):
"""
表示外星人的类
1. 主要有外星人数据的初始化
2. 绘制外星人的位置
3. 更新移动外星人后的位置
4. 检测外星人是否到达屏幕边缘
"""

def __init__(self, ai_settings, screen):
"""初始化外星人需要的数据"""
super(Alien, self).__init__()
self.screen = screen
self.ai_settings = ai_settings

# 加载外星人图像,并设置其rect属性
self.image = pygame.image.load('images/alien.bmp')
self.rect = self.image.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.image, self.rect)

def update(self):
"""向右移动外星人"""
self.x += (self.ai_settings.alien_speed_factor * self.ai_settings.fleet_direction)
self.rect.x = self.x

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
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
# 子弹对象
import pygame
from pygame.sprite import Sprite

class Bullet(Sprite):
"""
一个对飞船发射的子弹进行管理的类
1. 子弹参数的初始化
2. 更新子弹的位置
3. 在屏幕上绘制子弹
"""
def __init__(self, ai_settings, screen, ship):
"""初始化子弹参数""
super(Bullet, self).__init__()
self.screen = screen
self.color = ai_settings.bullet_color
self.speed_factor = ai_settings.bullet_speed_factor

# 在 (0,0) 处创建一个表示子弹的矩形,再设置正确的位置
self.rect = pygame.Rect(0, 0, ai_settings.bullet_width, ai_settings.bullet_hight)
self.rect.centerx = ship.rect.centerx
self.rect.top = ship.rect.top

# 存储用小数表示的子弹位置
self.y = float(self.rect.y)

def update(self):
"""向上移动子弹"""
# 更新表示子弹的小数位置值
self.y -= self.speed_factor
# 更新表示子弹的rect位置
self.rect.y = self.y

def draw_bullet(self):
"""在屏幕上绘制子弹"""
pygame.draw.rect(self.screen, self.color, self.rect)
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
# UI 界面对象
import pygame.font
from pygame.sprite import Group
from ship import Ship

class Scoreboard():
"""
显示得分信息的类
1. 初始化类
2. 显示当前得分
3. 显示最高分
4. 显示当前等级
5. 显示剩余飞船数
6. 将以上内容绘制在屏幕上
"""
def __init__(self, ai_settings, screen, stats):
"""初始化显示得分的涉及的属性"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats

# 显示得分信息时使用的字体设置
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)

# 准备初始得分图像
self.prep_score()
# 准备最高分图像
self.prep_high_score()
# 准备剩余的飞船数量
self.prep_ships()
# 准备玩家等级
self.prep_level()

def prep_score(self):
"""将得分转换为一副渲染的图像"""
rounded_score = int(round(self.stats.score, -1))
# 将得分格式化为 10,000,000 这种格式的数字
score_str = "{:,}".format(rounded_score)
# 渲染得分图像
self.score_image = self.font.render(score_str, True, self.text_color, self.ai_settings.bg_color)

# 将得分放在屏幕右上角
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right -20
self.score_rect.top = 20

def prep_high_score(self):
"""将最高得分转换为一副渲染的图像"""
high_score = int(self.stats.high_score)
# 将得分格式化
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True, self.text_color, self.ai_settings.bg_color)

# 将得分放在屏幕中间
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.centerx = self.screen_rect.centerx
self.high_score_rect.top = self.score_rect.top

def prep_level(self):
"""将等级转换为一副渲染的图像"""
self.level_image = self.font.render(str(self.stats.level), True, self.text_color, self.ai_settings.bg_color)

# 将等级放在得分下方
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.score_rect.right
self.level_rect.top = self.score_rect.bottom + 10

def prep_ships(self):
"""显示还剩下多少条飞船"""
# 将所有飞船放在一个组中,便于管理
self.ships = Group()
# 计算剩余飞船数
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)

def show_score(self):
"""在屏幕上显示当前得分、最高分、等级"""
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.high_score_image, self.high_score_rect)
self.screen.blit(self.level_image, self.level_rect)
self.ships.draw(self.screen)
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
# 游戏数据统计对象
import game_functions as gf

class GameStats(object):
"""
跟踪游戏的统计信息
1. 统计对象的初始化
2.
"""
def __init__(self, ai_settings):
"""初始化统计信息"""
self.ai_settings = ai_settings
self.reset_stats()

# 游戏刚启动时处于非活动状态
self.game_active = False

# 在任何情况下都不应该重置最高分
# 先从文件中读取,有则显示最高分,没有则显示0
read_high_score = gf.read_high_score()
# 判空
if read_high_score.strip() == '':
self.high_score = int(0)
else:
self.high_score = int(read_high_score)

def reset_stats(self):
"""初始化在游戏运行期间可能变化的统计信息"""
self.ships_left = self.ai_settings.ship_limit
self.score = 0
# 玩家等级
self.level = 1
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
# 开始游戏按钮对象
import pygame.font

class Button():
"""
开始游戏按钮
1. 初始化按钮属性
2. 设置按钮的文本
3. 在屏幕上绘制按钮
"""
def __init__(self, ai_settings, screen, msg):
"""初始化按钮的属性"""
self.screen = screen
self.screen_rect = screen.get_rect()

# 设置按钮的尺寸和其他属性
self.width, self.height = 200, 50
self.button_color = (0, 255, 0)
self.text_color = (255, 255, 255)
self.font = pygame.font.SysFont(None, 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_msg(self, msg):
"""将msg渲染为图像,并失去在按钮上居中"""
self.msg_image = self.font.render(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_botton(self):
# 绘制一个用颜色填充的按钮再绘制文本
self.screen.fill(self.button_color, self.rect)
self.screen.blit(self.msg_image, self.msg_image_rect)
  • 控制方法

通过game_funcations.py去串联各个对象

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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
# 串联各个对象
import sys
import pygame

from bullet import Bullet
from alien import Alien
from time import sleep

def check_events(ai_settings, screen, stats, sb, play_button, ship, aliens, bullets):
"""
响应按键和鼠标事件
1. 键盘按下和抬起要实现的操作
2. 鼠标按下,开启游戏
3. 将最高分写入文件
4. 更新子弹数量,删除击中到外星人的子弹,以及被击中的外星人
5. 创建一群外星人群
6. 检测游戏是否结束
"""
for event in pygame.event.get():
if event.type == pygame.QUIT:
# 按下q 退出游戏
write_high_score(stats)
sys.exit()
elif event.type == pygame.KEYDOWN:
check_keydown_events(event, ai_settings, screen, stats, ship, bullets)
elif event.type == pygame.KEYUP:
check_keyup_events(event, ship)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
check_play_button(ai_settings, screen, stats, sb, play_button, ship, aliens, bullets, mouse_x, mouse_y)

def check_play_button(ai_settings, screen, stats, sb, play_button, ship, aliens, bullets, mouse_x, mouse_y):
"""玩家单击开始按钮开始游戏"""
button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
if button_clicked and not stats.game_active:
# 重置游戏设置
ai_settings.initialize_dynamic_settings()
# 隐藏光标
pygame.mouse.set_visible(False)
# 重置游戏统计信息
stats.reset_stats()
stats.game_active = True

# 重置记分牌图像
sb.prep_score()
sb.prep_high_score()
sb.prep_level()
sb.prep_ships()

# 清空外星人列表和子弹列表
aliens.empty()
bullets.empty()

# 创建一群新的外星人,并让飞船居中
create_fleet(ai_settings, screen, ship, aliens)
ship.center_ship()

def check_keydown_events(event, ai_settings, screen, stats, ship, bullets):
# 响应鼠标按下事件
if event.key == pygame.K_RIGHT:
# 按下向右移动飞船
ship.moving_right = True
elif event.key == pygame.K_LEFT:
# 按下向左移动飞船
ship.moving_left = True
elif event.key == pygame.K_SPACE:
# 创建一颗子弹,并将其加入到编组bullets中, 控制只能发射3颗子弹
fire_bullet(ai_settings, screen, ship, bullets)
elif event.key == pygame.K_q:
# 按下q退出游戏
write_high_score(stats)
sys.exit()

def write_high_score(stats):
# 先读取文件,如果最高分比文件中的分数还低就不写入文件,否则写入文件
read_high_score_txt = int(read_high_score())
# 当前分数大于文件中的最高分,则写入文件
if read_high_score_txt < stats.high_score:
write_file = 'high_score.txt'
with open(write_file, 'w') as write_file_object:
write_file_object.write(str(stats.high_score))

def read_high_score():
"""读取文件中的最高分"""
read_file = 'high_score.txt'
with open(read_file) as read_file_object:
read_high_score = read_file_object.read()
return read_high_score

def check_keyup_events(event, ship):
# 响应鼠标松开事件
if event.key == pygame.K_RIGHT:
ship.moving_right = False
elif event.key == pygame.K_LEFT:
ship.moving_left = False

def update_bullets(ai_settings, screen, stats, sb, ship, aliens, bullets):
"""更新子弹的位置,并删除已经消失的子弹"""
bullets.update()
# 删除消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
# 响应子弹和外星人的碰撞
check_bullet_alien_collisions(ai_settings, screen, stats, sb, ship, aliens, bullets)

def check_bullet_alien_collisions(ai_settings, screen, stats, sb, ship, aliens, bullets):
# 删除发生碰撞的子弹和外星人
collisions = pygame.sprite.groupcollide(bullets, aliens,True, True)

# 统计击杀的外星人分数
if collisions:
for aliens in collisions.values():
stats.score += ai_settings.alien_points * len(aliens)
sb.prep_score()
# 检查是否诞生了新的最高分
check_high_score(stats, sb)

# 屏幕上外星人被杀光
if len(aliens) == 0:
# 删除现有的子弹,加快游戏节奏,并新建一群外星人
bullets.empty()
ai_settings.increase_speed()
create_fleet(ai_settings, screen, ship, aliens)

# 如果整群外星人被消灭了,就提高一个等级
stats.level += 1
sb.prep_level()

def check_high_score(stats, sb):
"""检查是否诞生了新的最高分"""
if stats.score > stats.high_score:
stats.high_score = stats.score
sb.prep_high_score()

def fire_bullet(ai_settings, screen, ship, bullets):
"""如果还没达到子弹的发射上限,就发射一颗子弹"""
if len(bullets) < ai_settings.bullets_allowed:
new_bullet = Bullet(ai_settings, screen, ship)
bullets.add(new_bullet)

def get_number_aliens_x(ai_settings, alien_width):
# 外星人间距为外星人的宽度 计算一行可容纳多少个外星人
available_space_x = ai_settings.screen_width - 2 * alien_width
number_aliens_x = int(available_space_x / (2 * alien_width))
return number_aliens_x

def get_number_rows(ai_settings, ship_height, alien_height):
"""计算屏幕可以容纳多少行外星人"""
available_space_y = (ai_settings.screen_height - (3 * alien_height) - ship_height)
number_rows = int(available_space_y / (2 * alien_height))
return number_rows

def create_alien(ai_settings, screen, aliens, alien_number, row_number):
# 创建一个外星人
alien = Alien(ai_settings, screen)
alien_width = alien.rect.width
# 外星人的坐标
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
aliens.add(alien)

def create_fleet(ai_settings, screen, ship, aliens):
"""创建外星人群"""
alien = Alien(ai_settings, screen)
number_aliens_x = get_number_aliens_x(ai_settings, alien.rect.width)
number_rows = get_number_rows(ai_settings,ship.rect.height, alien.rect.height)

# 创建第一行外星人
"""
for alien_number in range(number_aliens_x):
# 创建一个外星人并将其加入当前行
alien = Alien(ai_settings, screen)
create_alien(ai_settings, screen, aliens, alien_number)
"""
# 创建外星人群
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
# 创建一个外星人并将其加入当前行
alien = Alien(ai_settings, screen)
create_alien(ai_settings, screen, aliens, alien_number, row_number)

def update_aliens(ai_settings, screen, stats, sb, ship, aliens, bullets):
"""检查是否有外星人在屏幕边缘,并更新正群外星人的位置"""
check_fleet_edges(ai_settings, aliens)
aliens.update()
# 检测外星人和飞船之间的碰撞
if pygame.sprite.spritecollideany(ship, aliens):
print("Ship hit!!!")
ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets)

check_aliens_bottom(ai_settings, screen, stats, sb, ship, aliens, bullets)

def check_fleet_edges(ai_settings, aliens):
"""有外星人到达边缘时采取响应的措施"""
for alien in aliens.sprites():
if alien.check_edges():
change_fleet_direction(ai_settings, aliens)
break
def change_fleet_direction(ai_settings, aliens):
"""将整体外星人下移,并改变他们的方向"""
for alien in aliens.sprites():
alien.rect.y += ai_settings.fleet_drop_speed
ai_settings.fleet_direction *= -1

def ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets):
# 响应被外星人撞到的飞船
if stats.ships_left > 0:
# 将ship_left减1
stats.ships_left -= 1
# 更新飞船数
sb.prep_ships()
# 清空外星人列表和子弹列表
aliens.empty()
bullets.empty()

# 创建一群新的外星人,并将飞创放到屏幕底部的中间
create_fleet(ai_settings, screen, ship, aliens)
ship.center_ship()

# 暂停
sleep(0.5)
else:
stats.game_active = False
# 非游戏状态显示光标
pygame.mouse.set_visible(True)

def check_aliens_bottom(ai_settings, screen, stats, sb, ship, aliens, bullets):
"""检查是否有外星人到达屏幕底部"""
screen_rect = screen.get_rect()
for alien in aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
# 像飞船被撞到一样处理
ship_hit(ai_settings, stats, screen, sb, ship, aliens, bullets)
break

def update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets, play_button):
"""更新屏幕上的图像,并切换到新的屏幕"""
# 每次循环时都重绘屏幕
screen.fill(ai_settings.bg_color)
# 在飞船和外星人后面重绘所有子弹
for bullet in bullets.sprites():
bullet.draw_bullet()

# 在指定位置绘制飞船
ship.blitme()
aliens.draw(screen)

# 显示得分
sb.show_score()

# 如果游戏处于非活动状态,就绘制Play按钮
if not stats.game_active:
play_button.draw_botton()

# 让最近绘制的屏幕可见
pygame.display.flip()
小额支持我写出更好的文章~