这两天的真的很忙。。
就一直没有更新博客。今天抽时间，整理一下项目一所剩余的部分。
对于项目一，确实有些杂，但是我们只要理清其中的思路即可。毕竟第一次的项目，往后要不断回顾才是。
这样吧，我附上整个项目的代码。有什么不懂的地方可以留言问我。
alien_invasion.py代码
# 02 import sys
import pygame
from settings import Setting # 01
from ship import Ship # 01
import game_function as gf # 02
from pygame.sprite import Group # 03 pygame.sprite.Group 类类似于列表，但提供了有助于开发游戏的额外功能
# from aliens import Alien # 04
from game_stats import GameStats # 04
from button import Button # 05
from scoreboard import Scoreboard # 05
def run_game(): # 初始化游戏，并且创建一个屏幕对象
pygame.init() # 初始化背景设置，让Pygame能够正确地工作
# 01 screen = pygame.display.set_mode((1200, 800)) # 创建一个名为screen 的显示窗口，括号里是元组！！！
# 01 # 这个游戏的所有图形元素都将在其中绘制
ai_set = Setting() # 因为导入类而做了代码替换
screen = pygame.display.set_mode(
(ai_set.screen_width, ai_set.screen_height)
)
# 01 bg_color = (230,230,230) # 设置背景颜色
pygame.display.set_caption('外星人入侵')
# 创建一个play按钮
play_button = Button(ai_set, screen, 'Play')
# 创建一个用于存储游戏统计信息的实例 并【创建记分牌】
stats = GameStats(ai_set)
sb = Scoreboard(ai_set, screen, stats)
# 创建一艘飞船对象
ship = Ship(ai_set, screen)
# 03 导入Group类并且创建一个Group实例，用于存储子弹的编组
bullets = Group()
# 04 创建一个外星人,编组
# alien = Alien(ai_set,screen)
aliens = Group()
# 04 创建外星人群
gf.create_fleet(ai_set, screen, ship, aliens)
# 为让程序响应事件，我们编写一个事件循环，以侦听事件，并根据发生的事件执行相应的任务。
while True: # 游戏的主循环
# 02 for event in pygame.event.get(): # 监视键盘和鼠标
# 02 if event.type == pygame.QUIT: #编写一系列的if 语句来检测并响应特定的事件
# 02 sys.exit() # 我们调用sys.exit() 来退出游戏
gf.check_event(ai_set, screen, stats, sb, play_button, ship, aliens, bullets) # 02 03 05 06
if stats.game_active:
ship.update() # 02
gf.update_bullet(ai_set, screen, stats, sb, ship, aliens, bullets) # 03 04 05
gf.update_aliens(ai_set, screen, stats, sb, ship, aliens, bullets) # 04 06
# 03 bullets.update() # 03
# # 03 删除已经消失，看不到的子弹
# for bull in bullets.copy():
# if bull.rect.bottom <= 0:
# bullets.remove(bull)
# print(len(bullets))
# 01screen.fill(bg_color) # 每次循环都重绘屏幕
# 02 screen.fill(ai_set.bg_color)
# 02 ship.blitme() # 调用blitme函数，使飞船出现
# 02 pygame.display.flip() # 让最近绘制的屏幕可见
gf.update_screen(ai_set, screen, stats, sb, ship, aliens, bullets, play_button) # 02 03 04 05
run_game()
input()
game_function.py代码
import sys
import pygame
from settings import Setting
from bullet import Bullet # 03
from aliens import Alien # 04
from time import sleep # 04
from game_stats import GameStats # 05
# 响应按键 03
def check_keydown(event, ai_settings, screen, ship, bullets):
if event.key == pygame.K_RIGHT:
# 向右移动飞船
ship.moving_right = True
# ship.rect.centerx += 10
elif event.key == pygame.K_LEFT:
# 向左移动飞船
# ship.rect.centerx -= 10
ship.moving_left = True
# 03 创建一颗子弹，并将其加入到编组bullets中
elif event.key == pygame.K_SPACE:
if len(bullets) < ai_settings.bullet_allowed: # 限制三个子弹
# 玩家按空格键时，创建一颗新子弹（一个名为new_bullet 的Bullet 实例），
new_bullet = Bullet(ai_settings, screen, ship)
# 并使用方法add() 将其加入到编组bullets中
bullets.add(new_bullet)
# 04 按q结束
elif event.key == pygame.K_q:
sys.exit()
# 响应松开 03
def check_keyup(event, ship):
if event.key == pygame.K_RIGHT:
ship.moving_right = False
elif event.key == pygame.K_LEFT:
ship.moving_left = False
# 响应按键和鼠标事件
def check_event(ai_setting, screen, stats, sb, play_button, ship, aliens, bullets): # 03
for i in pygame.event.get():
if i.type == pygame.QUIT:
sys.exit()
elif i.type == pygame.KEYDOWN:
check_keydown(i, ai_setting, screen, ship, bullets) # 重构
# 03 if i.key == pygame.K_RIGHT:
# 03 # 向右移动飞船
# 03 ship.moving_right = True
# 03 # ship.rect.centerx += 10
# 03 elif i.key == pygame.K_LEFT:
# 03 # 向左移动飞船
# 03 # ship.rect.centerx -= 10
# 03 ship.moving_left = True
elif i.type == pygame.KEYUP:
check_keyup(i, ship) # 重构
# 03 if i.key == pygame.K_RIGHT:
# 03 ship.moving_right = False
# 03 elif i.key == pygame.K_LEFT:
# 03 ship.moving_left = False
# 05 鼠标点击事件
elif i.type == pygame.MOUSEBUTTONDOWN:
# 无论玩家单击屏幕的什么地方，Pygame都将检测到一个MOUSEBUTTONDOWN 事件
# 但我们只想让这个游戏在玩家用鼠标单击Play按钮时作出响应
# 为此，我们使用了pygame.mouse.get_pos() ，它返回一个元组，其中包含玩家单击时鼠标的x 和y 坐标
mouse_x, mouse_y = pygame.mouse.get_pos()
# 我们将这些值传递给函数check_play_button()
# 而这个函数使用collidepoint() 检查鼠标单击位置是否在Play按钮的rect 内
check_play_button(ai_setting, screen, stats, sb, play_button, ship, aliens, bullets, mouse_x, mouse_y)
# 05 在玩家单击play按钮时开始新的游戏
def check_play_button(ai_setting, screen, stats, sb, play_button, ship, aliens, bullets, mouse_x, mouse_y):
# 仅当玩家单击了Play按钮且 游戏当前处于非活动状态时，游戏才重新开始
# collidepoint() 检查鼠标单击位置是否在Play按钮的rect 内
button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
if button_clicked and not stats.game_active: # 控制仅仅在按钮区域,且 游戏停止状态 才会重置
# 重置游戏的设置，如初始速度等
ai_setting.initialize_dynamic_settings()
# 隐藏光标,直到游戏重开时出现，修改visible状态的代码写到ship_hit()中
pygame.mouse.set_visible(False)
# 重置游戏统计信息
stats.reset_stats()
stats.game_active = True
# 06 为确保开始新游戏时更新记分和等级图像，在按钮Play被单击时触发重置
sb.prep_score()
sb.prep_high_score()
sb.prep_level()
# 06 我们在开始新游戏时调用prep_ships()
sb.prep_ship()
# 清空外星人列表和子弹列表
aliens.empty()
bullets.empty()
# 创建一群新的外星人，并让飞船居中
create_fleet(ai_setting, screen, ship, aliens)
ship.center_ship() # ship.py中的函数
# -------------------------------------更新屏幕-------------------------------------
# 更新屏幕上的图像，并切换到新屏幕
def update_screen(ai_setting, screen, stats, sb, ship, aliens, bullets, play_button):
# 每次循环时都重绘屏幕
screen.fill(ai_setting.bg_color)
# 03 在飞船和外星人后面重绘所有子弹
# 为在屏幕上绘制发射的所有子弹，我们遍历编组bullets 中的精灵，并对每个精灵都调用draw_bullet()
for bullet in bullets.sprites():
bullet.draw_bullet()
ship.blitme()
# 04 alien.blitme()
aliens.draw(screen) # 04 绘制外星人，使用的是内置draw函数
# 06 显示得分
sb.show_score()
# 05 如果处于非游戏状态，就绘制play按钮
if not stats.game_active:
play_button.draw_button() # 此函数在button.py文件
# 让最近绘制的屏幕可见
pygame.display.flip()
# -------------------------------------以下是子弹----------------------------------------------
# 03 更新子弹位置，并删除已经消失的子弹
def update_bullet(ai_setting, screen, stats, sb, ship, aliens, bullets): # 05
bullets.update() # 更新子弹位置
# 03 删除已经消失，看不到的子弹
for bull in bullets.copy():
if bull.rect.bottom <= 0:
bullets.remove(bull)
print(len(bullets))
# ----- 04 检查是否碰撞-------
check_bullet_alien_collision(ai_setting, screen, stats, sb, ship, aliens, bullets) # 05
# 检查子弹和外星人是否碰撞
def check_bullet_alien_collision(ai_setting, screen, stats, sb, ship, aliens, bullets):
# 方法sprite.groupcollide() 将每颗子弹的rect 同每个外星人的rect 进行比较，并返回一个字典，
# 其中包含发生了碰撞的子弹和外星人。在这个字典中，每个键都是一颗子弹，而相应的值都是被击中的外星人
# 检查是否有子弹击中了外星人
# 如果是这样，就删除相应的子弹和外星人
collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)
# 05 若碰撞则加分
if collisions:
# 如果字典collisions 存在，我们就遍历其中的所有值。
# 别忘了，每个值都是一个列表，包含被同一颗子弹击中的所有外星人。
# 对于每个列表，都将一个外星人的点数乘以其中包含的外星人数量，并将结果加入到当前得分中
for alie in collisions.values():
# 有子弹撞到时，Pygame返回一个字典（collisions ）。
# 我们检查这个字典是否存在，如果存在，就将得分加上一个外星人值的点数
stats.score += ai_setting.alien_point * len(alie)
sb.prep_score() # 此函数在scoreboard.py文件中
check_high_score(stats, sb) # 此函数在本页最后
# 如果外星人编组为空，则删除现有子弹并新建一群外星人
# 06 如果整群外星人都被消灭，就提高一个等级
if len(aliens) == 0:
bullets.empty()
ai_setting.increase_speed() # 增加游戏节奏
# 06 提高等级
stats.level += 1
sb.prep_level()
create_fleet(ai_setting, screen, ship, aliens)
# ai_setting.fleet_drop_speed += 20 # 自己加的----------------------------------------------------
# -------------------------------------以下是外星人 04 --------------------------------------------
# 04 创建外星人群
def create_fleet(ai_setting, screen, ship, aliens):
# 创建一个外星人，并计算一行可容纳多少个外星人
# 外星人间距为外星人宽度
# 我们先创建一个外星人,这个外星人不是外星人群的成员，因此没有将它加入到编组aliens 中
ali = Alien(ai_setting, screen)
number_alien_x = get_number_aliens_x(ai_setting, ali.rect.width) # 04 重构create_fleet
number_rows = get_number_row(ai_setting, ship.rect.height, ali.rect.height)
# 04 # 我们从外星人的rect 属性中获取外星人宽度，并将这个值存储到alien_width 中，以免反复访问属性rect
# 04 ali_width = ali.rect.width
# 04 # 我们计算可用于放置外星人的水平空间，以及其中可容纳多少个外星人。
# 04 available_space_x = ai_setting.screen_width - 2 * ali_width
# 04 number_alien_x = int(available_space_x / (2 * ali_width))
# 创建第一行外星人
for row_num in range(number_rows):
for ali_num in range(number_alien_x):
# 创建一个外星人，并加入当前行
# alien = Alien(ai_setting,screen) # 通过设置x 坐标将其加入当前行
# alien.x = ali_width + 2 * ali_width * ali_num
# alien.rect.x = alien.x
# aliens.add(alien)
create_alien(ai_setting, screen, aliens, ali_num, row_num) # 04 重构create_fleet
# 计算每行可容纳多少个外星人
def get_number_aliens_x(ai_setting, alien_width):
available_space_x = ai_setting.screen_width - 2 * alien_width
number_alien_x = int(available_space_x / (2 * alien_width))
return number_alien_x
# 计算屏幕可容纳多少行外星人
def get_number_row(ai_setting, ship_height, alien_height):
available_space_y = (ai_setting.screen_height - (3 * alien_height) - 3.5 * ship_height)
number_rows = int(available_space_y / (2 * alien_height))
return number_rows
# 创建一个外星人并将其放在当前行
def create_alien(ai_setting, screen, aliens, alien_number, row_number):
alien = Alien(ai_setting, screen) # 通过设置x 坐标将其加入当前行
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 # 创建时，计算y的坐标
aliens.add(alien)
# 更新外星人群中所有外星人位置
def update_aliens(ai_set, screen, stats, sb, ship, alie, bullets):
# 检查是否有外星人到达屏幕边，然后更新所有外星人的位置
check_fleet_edges(ai_set, alie)
alie.update()
# 04 检测外星人和飞船之间的碰撞
# 方法spritecollideany() 接受两个实参：一个精灵和一个编组。
# 它检查编组是否有成员与精灵发生了碰撞，并在找到与精灵发生了碰撞的成员后就停止遍历编组。
if pygame.sprite.spritecollideany(ship, alie):
ship_hit(ai_set, screen, stats, sb, ship, alie, bullets)
# 检测是否有外星人到达屏幕底部
check_aliens_bottom(ai_set, screen, stats, sb, ship, alie, bullets)
# 检测是否有外星人到达的屏幕底端
def check_aliens_bottom(ai_setting, screen, stats, sb, ship, aliens, bullets):
screen_rect = screen.get_rect()
for ali in aliens.sprites():
if ali.rect.bottom >= screen_rect.bottom:
# 像飞船撞到外星人一样处理
ship_hit(ai_setting, screen, stats, sb, ship, aliens, bullets)
break
# 响应被外星人撞到的飞船
def ship_hit(ai_setting, screen, stats, sb, ship, aliens, bullets):
if stats.ships_left > 0:
# 将ships_left减一
stats.ships_left -= 1
# 我们还在飞船被外星人撞到时调用prep_ships() ，从而在玩家损失一艘飞船时更新飞船图像：
sb.prep_ship()
# 清空外星人和子弹列表
aliens.empty()
bullets.empty()
# 重新创建一群新的外星人，并将飞船放到屏幕底部
create_fleet(ai_setting, screen, ship, aliens)
ship.center_ship() # ship.py中的函数
# 暂停0.5秒
sleep(0.5)
else:
stats.game_active = False
# 使光标出现
pygame.mouse.set_visible(True)
# 有外星人到达边缘时，采取相应的措施
def check_fleet_edges(ai_setting, aliens):
for ali in aliens.sprites(): # 我们遍历外星人群，并对其中的每个外星人调用check_edge()
if ali.check_edge(): # aliens.py中有此函数
change_fleet_direction(ai_setting, aliens)
break
# 将整群外星人下移，并改变它们的方向
def change_fleet_direction(ai_set, aliens):
for ali in aliens.sprites():
ali.rect.y += ai_set.fleet_drop_speed
ai_set.fleet_direction *= -1
# ---------------------------------------以下是检测是否诞生最高分----------------------------------------
def check_high_score(stats, sb):
if stats.score > stats.high_score:
stats.high_score = stats.score
sb.prep_high_score()
ship.py代码
import pygame
from pygame.sprite import Sprite # 06
class Ship(Sprite):
def __init__(self, ai_setting, screen): # 初始化飞船，并设置初始位置
super().__init__() # 06 继承初始化
self.screen = screen
self.ai_setting = ai_setting # 02
# 加载飞船图像并获取其外接矩形
self.image = pygame.image.load('.\\feii.bmp')
self.rect = self.image.get_rect() # 我们使用get_rect() 获取相应surface的属性rect
self.screen_rect = self.screen.get_rect()
# 将每艘新飞船放在屏幕底部中央
# 要将游戏元素居中，可设置相应rect 对象的属性center 、centerx 或centery 。
self.rect.centerx = self.screen_rect.centerx
# 要让游戏元素与屏幕边缘对齐，可使用属性top 、bottom 、left 或right ；
# 要调整游戏元素的水平或垂直位置，可使用属性x 和y ，它们分别是相应矩形左上角的 x 和 y 坐标。
self.rect.bottom = self.screen_rect.bottom
# 在飞船的属性center中存储小数数值
self.center = float(self.rect.centerx) # 小数形式的位移可以更好的控制飞船移动
# 移动标志，# 02
# 飞船不动时，标志moving_right将为False 。
# 玩家按下右箭头键时，我们将这个标志设置为True ；而玩家松开时，我们将这个标志重新设置为False
self.moving_right = False
self.moving_left = False
self.moving_up = False
self.moving_down = False
# 根据移动标志，移动飞船 # 02
def update(self):
if self.moving_right and self.rect.right < self.screen_rect.right: # 控制飞船移动的左右范围
# 02 self.rect.centerx += 1
# 02 更新飞船的center值，而不是rect
self.center += self.ai_setting.ship_speed_factor
if self.moving_left and self.rect.left > 0:
# 02 self.rect.centerx -= 1
self.center -= self.ai_setting.ship_speed_factor
# 根据self.center更新rect对象
self.rect.centerx = self.center
# 我们定义了方法blitme() ，它根据self.rect 指定的位置将图像绘制到屏幕上
# 在指定位置绘制飞船
def blitme(self):
self.screen.blit(self.image, self.rect) # 把image这个surface对象贴到rect的位置
# 让飞船在屏幕上居中
def center_ship(self):
self.center = self.screen_rect.centerx
aliens.py代码
import pygame
from pygame.sprite import Sprite
# 表示单个外星人的类
class Alien(Sprite):
# 初始化外星人并设置其起始位置
def __init__(self, ai_setting, screen):
super().__init__()
self.screen = screen
self.ai_setting = ai_setting
# 加载外星人图形，并设置其rect属性
self.image = pygame.image.load(r'.\\alien-1.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)
# 如果外星人处于屏幕边缘，就返回True,此函数会在game_function中用到
# 如果外星人处于屏幕边缘，就返回True,此函数会在game_function中用到
def check_edge(self):
screen_rect = self.screen.get_rect()
if self.rect.right >= screen_rect.right:
return True
elif self.rect.left <= screen_rect.left:
return True
# 向左或向右移动外星人
def update(self, *args):
self.x += self.ai_setting.alien_speed_factor * self.ai_setting.fleet_direction
self.rect.x = self.x
bullet.py代码
import pygame
from pygame.sprite import Sprite # 导入精灵
# 一个对飞船发射的子弹进行管理的类
class Bullet(Sprite):
def __init__(self, ai_setting, screen, ship):
# 在飞船所处的位置创建一个子弹对象
super().__init__() # 初始化父类 2.7写法super(Bullet,self).__init__()
self.screen = screen
# 在（0，0）处创建一个表示子弹的矩形，再设置正确的位置
# 我们创建了子弹的属性rect 。子弹并非基于图像的，因此我们必须使用pygame.Rect()类从空白开始创建一个矩形
# 我们在(0, 0)处创建这个矩形，但接下来的两行代码将其移到了正确的位置
# self.rect = pygame.Rect(0,0,ai_setting.bullet_width,ai_setting.bullet_height)-------原版，下两行DIY-------
self.image = pygame.image.load('.\\Heart7.bmp')
self.rect = self.image.get_rect()
# 我们将子弹的centerx设置为飞船的rect.centerx 。
# 子弹应从飞船顶部射出，因此我们将表示子弹的rect的top属性设置为飞船的rect的top属性，
# 让子弹看起来像是从飞船中射出的
self.rect.centerx = ship.rect.centerx
self.rect.top = ship.rect.top
# 存储用小数表示的子弹位置
self.y = float(self.rect.y)
self.color = ai_setting.bullet_color
self.speed = ai_setting.bullet_speed_factor
# 向上移动子弹
def update(self, *args):
# 更新表示子弹位置的小数值
self.y -= self.speed / 2
# 更新表示子弹位置的rect的位置
self.rect.y = self.y
# 在屏幕上绘制子弹
def draw_bullet(self):
# 函数draw.rect()使用存储在self.color中的颜色填充表示子弹的rect占据的屏幕部分
# pygame.draw.rect(self.screen,self.color,self.rect)-----------------------原版，下一行DIY-------------------
self.screen.blit(self.image, self.rect)
button.py代码
import pygame.sysfont
class Button():
# 初始化按钮属性
def __init__(self, ai_setting, 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.sysfont.SysFont('arial', 48)
# 创建按钮的rect对象，并使其居中
# 为让按钮在屏幕上居中，我们创建一个表示按钮的rect 对象
# 并将其center 属性设置为屏幕的center 属性
self.rect = pygame.Rect(0, 0, self.width, self.height)
self.rect.center = self.screen_rect.center
# 按钮的标签只需创建一次
# Pygame通过将你要显示的字符串渲染为图像来处理文本。我们调用prep_msg() 来处理这样的渲染
self.prep_msg(msg)
# 将msg渲染为图像，并使其在按钮上居中
def prep_msg(self, 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
# 最后，我们创建方法draw_button() ，通过调用它可将这个按钮显示到屏幕上
def draw_button(self):
# 绘制一个用颜色填充的按钮，再绘制文本
self.screen.fill(self.button_color, self.rect)
self.screen.blit(self.msg_image, self.msg_image_rect)
game_stats.py代码
# 跟踪游戏的统计信息
class GameStats():
# 初始化统计信息
def __init__(self, ai_setting):
self.ai_setting = ai_setting
self.reset_stats()
# # 游戏刚开始时处于活动状态
# self.game_active = True
# 游戏刚开始时处于停止状态，直到play按钮按下
self.game_active = False # 05
# 在任何情况下都不重置最高分
self.high_score = 0
# 初始化在游戏运行期间可能变化的统计信息
def reset_stats(self):
self.ships_left = self.ai_setting.ship_limit
self.score = 0 # 05 记分，在每次游戏开始时，重置记分
self.level = 1 # 06 等级
scoreboard.py代码
import pygame.sysfont
from pygame.sprite import Group # 06
from ship import Ship # 06
# 显示得分信息的类
class Scoreboard():
# 初始化显示涉及得分的属性
def __init__(self, ai_setting, screen, stats):
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_setting = ai_setting
self.stats = stats
# 显示得分信息时使用的字体设置
self.text_color = (30, 30, 30)
self.font = pygame.sysfont.SysFont('arial', 48)
# 准备初始得分图像
self.prep_score() # 为将要显示的文本转换为图像
# 准备最高分的图像
self.prep_high_score()
# 06 准备显示等级的图像
self.prep_level()
# 06 准备显示剩余飞船的图像
self.prep_ship()
# 将得分转换为一副渲染的图像
def prep_score(self):
round_score = round(self.stats.score)
score_str = '{:,}'.format(round_score)
self.score_image = self.font.render(score_str, True, self.text_color, self.ai_setting.bg_color)
# 将得分放到屏幕右上角
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 20 # 让其上边缘与屏幕上边缘也相距20像素
# 将最高分渲染为图像
def prep_high_score(self):
high_score = round(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_setting.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.screen_rect.top
# 06 等级渲染为图像
def prep_level(self):
self.leve_image = self.font.render(str(self.stats.level), True, self.text_color, self.ai_setting.bg_color)
# 将等级放在得分下方
self.level_rect = self.leve_image.get_rect()
self.level_rect.right = self.screen_rect.right - 20
self.level_rect.top = self.score_rect.bottom + 10
# 06 显示剩余多少飞船
def prep_ship(self):
# 方法prep_ships() 创建一个空编组self.ships ，用于存储飞船实例
self.ships = Group()
# 为填充这个编组，根据玩家还有多少艘飞船运行一个循环相应的次数
for ship_num in range(self.stats.ships_left):
# 在这个循环中，我们创建一艘新飞船，并设置其x 坐标，
# 让整个飞船编组都位于屏幕左边，且每艘飞船的左边距都为10像素
# 我们还将y 坐标设置为离屏幕上边缘10像素，让所有飞船都与得分图像对齐
ship = Ship(self.ai_setting, self.screen)
ship.rect.x = 10 + ship_num * ship.rect.width
ship.rect.y = 10
# 最后，我们将每艘新飞船都添加到编组ships 中
self.ships.add(ship)
# 在屏幕上显示得分
def show_score(self):
# 这个方法将得分图像显示到屏幕上，并将其放在score_rect 指定的位置
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.high_score_image, self.high_score_rect)
self.screen.blit(self.leve_image, self.level_rect) # 06
# 为在屏幕上显示飞船，我们对编组调用了draw() 。Pygame将绘制每艘飞船。
self.ships.draw(self.screen)
settings.py代码
class Setting(): # 存储《外星人入侵》中所有的设置类
def __init__(self): # 初始化游戏设置
self.screen_width = 1200 # 屏幕设置
self.screen_height = 800
self.bg_color = (230, 230, 230)
# self.ship_speed_factor = 2.5 # 02 设置飞船速度
# 03 子弹设置
# 05 self.bullet_speed_factor = 3 # 子弹速度
self.bullet_width = 500 # 子弹宽度
self.bullet_height = 3 # 子弹长度
self.bullet_color = 60, 60, 60 # 子弹颜色
self.bullet_allowed = 3 # 限制子弹数量为３
# 04 外星人设置
# 05 self.alien_speed_factor = 1
self.fleet_drop_speed = 10
# 05 # fleet_direction为1表示向右移动，为-1表示向左移动
# self.fleet_direction = 1
# 04 飞船设置
self.ship_limit = 2
# 以什么样的速度加快游戏节奏
self.speedup_scale = 1.1
# 玩家每提高一个等级，游戏都变得更难，因此处于较高的等级时，外星人的点数应更高。
# 外星人点数的提高速度
self.score_scale = 1.5
# 05 我们将动态变量 和 静态变量分开
# 调用initialize_dynamic_settings() ，以初始化随游戏进行而变化的属性
self.initialize_dynamic_settings()
# 05 初始化随游戏进行而变化的设置
def initialize_dynamic_settings(self):
self.bullet_speed_factor = 3 # 子弹速度
self.alien_speed_factor = 0.8
self.ship_speed_factor = 1.5 # 02 设置飞船速度
# fleet_direction为1表示向右移动，为-1表示向左移动
self.fleet_direction = 1
# 05 记分
# 随着游戏的进行，我们将提高每个外星人值的点数。
# 为确保每次开始新游戏时这个值都会被重置，我们在initialize_dynamic_settings() 中设置它。
self.alien_point = 50
# 05 每当玩家提高一个等级时，我们都使用increase_speed() 来提高飞船、子弹和外星人的速度
# 提高速度
def increase_speed(self):
self.ship_speed_factor *= self.speedup_scale
self.alien_speed_factor *= self.speedup_scale
self.ship_speed_factor *= self.speedup_scale
self.alien_point = int(self.alien_point * self.score_scale)