Python项目 | 外星人入侵之外星人

外星人

上一章完成了飞船部分的代码Python项目 | 外星人入侵之武装飞船

接下来本章在游戏《外星人入侵》中添加外星人。首先，我们在屏幕上边缘附近添加一个外星人，然后生成一群外星人。我们让这群外星人向两边和下面移 动，并删除被子弹击中的外星人。最后，我们将显示玩家拥有的飞船数量，并在玩家的飞船用完后结束游戏。

1、回顾项目

在进入下一个开发阶段前先回顾一下开发计划，搞清楚接下来要通过编写代码完成哪些任务。

1. 研究既有代码，确定实现新功能前是否要进行重构。
2. 在屏幕左上角添加一个外星人，并指定合适的边距。
3. 根据第一个外星人的边距和屏幕尺寸计算屏幕上可容纳多少个外星人。编写一个循环创建一系列外星人，这些外星人填满屏幕的上半部分。
4. 让外星人群向两边和下方移动，直到外星人被全部击落，有外星人撞到飞船，或有外星人抵达屏幕底端。如果整群外星人都被击落，再创建一群外星人。如果有外星人撞到飞船或抵达屏幕底端，将销毁飞船并在创建一群外星人。
5. 限制玩家可用的飞船数量，配给的飞船用完后，游戏结束。

在给项目添加新功能前，还应审核既有代码。每进入一个新阶段，通常项目都会更复杂，因此最好对混乱或低效的代码进行清理。 每次为测试新功能而运行这个游戏时，都必须使用鼠标来关闭它，不方便。添加一个结束游戏的快捷键Q：

game_function.py

def check_keydown_events(event, ai_settings, screen, ship, bullets):
    # skip

    elif event.key == pygame.K_q:    #快捷键q结束游戏
        sys.exit()

2、创建第一个外星人

在屏幕上放置外星人与放置飞船类似。每个外星人的行为都由Alien 类控制，像创建Ship 类那样创建这个类。确定一外星人位图并将图像文件保存到文件夹images中。

【1】创建Alien类

alien.py

import  pygame
from  pygame.sprite import Sprite

class Alien(Sprite):
    # 表示单个外星人的类

    def _init_(self,ai_settings,screen):
        # 初始化外星人并设置其起始位置
        super().__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)

除位置不同外，这个类的大部分代码都与Ship 类相似。每个外星人最初都位于屏幕左上角附近，将每个外星人的左边距都设置为外星人的宽度，并将上边距设置为外星人的高度。

【2】创建Alien实例

alien.invasion.py

#skip

from  ship import Ship
from alien import  Alien
import game_functions as gf
from  pygame.sprite import  Group


def run_game():
    # skip

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

    # 开始游戏的主循环
    while True:
        # 监视键盘和鼠标
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        gf.update_bullets(bullets)
        gf.update_screen(ai_settings, screen, ship, alien, bullets)

run_game()

导入了新创建的Alien 类，并在进入主while 循环前创建了一个Alien 实例，并修改了 对update_screen() 的调用，传递了一个外星人实例。

【3】让外星人出现在屏幕上

在update_screen() 中调用其方法blitme() ：

game_function.py

def update_screen(ai_settings, screen, ship, alien, bullets):
    # skip

    # 在飞船和外星人后面重新重绘所有子弹
    for bullet in bullets.sprites():
         bullet.draw_bullet()
    ship.blitme()
    alien.blitme()
    # 不断更新屏幕，让最近绘制的屏幕可见
    pygame.display.flip()

先绘制飞船和子弹，再绘制外星人，让外星人在屏幕上位于最前面。第一个外星人：

3、创建一群外星人

要绘制一群外星人，需要确定一行能容纳多少个外星人以及要绘制多少行外星人。首先计算外星人之间的水平间距，并创建一行外星人，再确定可用的垂直空间，并创建整群外星人。

【1】确定一行可容纳多少外星人

先看可用的水平空间有多大。屏幕宽度存储在ai_settings.screen_width 中，但需要在屏幕两边都留下一定的边距，把它设置为 外星人的宽度。由于有两个边距，因此可用于放置外星人的水平空间为屏幕宽度减去外星人宽度的两倍：

available_space_x = ai_settings.screen_width – (2 * alien_width)

还需要在外星人之间留出一定的空间，即外星人宽度。因此，显示一个外星人所需的水平空间为外星人宽度的两倍：一个宽度用于放置外星人，另一个宽度为外星人右边的空白区域。为确定一行可容纳多少个外星人，我们将可用空间除以外星人宽度的两倍：

number_aliens_x = available_space_x / (2 * alien_width)

【2】创建多行外星人

为创建一行外星人，先在alien_invasion.py中创建一个名为aliens 的空编组，用于存储全部外星人，再调用game_functions.py中创建外星人群的函数：

alien_invasion.py

# skip

def run_game():
    # skip

    # 创建一艘飞船
    ship = Ship(ai_settings, screen)
    # 创建一个用于存储子弹的编组
    bullets = Group()
    # 创建一个外星人编组
    aliens = Group()

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

   
    # 开始游戏的主循环
    while True:
        # skip

        gf.update_screen(ai_settings, screen, ship, aliens, bullets)

run_game()

修改update_screen()：

game_function.py

def update_screen(ai_settings, screen, ship, aliens, bullets):
    # skip

    ship.blitme()
    aliens.draw(screen)  # 在屏幕上绘制编组中的每个外星人。
    # 不断更新屏幕，让最近绘制的屏幕可见
    pygame.display.flip()

对编组调用draw() 时，Pygame自动绘制编组的每个元素，绘制位置由元素的属性rect 决定。

【3】创建外星人群

创建函数creat_fleet()：

game_function.py

def create_fleet(ai_settings, screen, aliens):
    # 创建外星人群
    # 创建一个外星人，并计算一行可容纳多少个外星人
    # 外星人间距为外星人宽度
    alien = Alien(ai_settings, screen)
    alien_width = alien.rect.width  # 从外星人的rect 属性中获取外星人宽度
    avaliable_space_x = ai_settings.screen_width - 2 * alien_width
    number_aliens_x =int(avaliable_space_x / (2 * alien_width))

    # 创建第一行外星人
    for alien_number in range(number_aliens_x):
        # 创建一个外星人并将其加入当前行
        alien = Alien(ai_settings,screen)
        alien.x = alien_width + 2 * alien_width * alien_number
        alien.rect.x = alien.x
        aliens.add(alien)

编写一个循环，它从零数到要创建的外星人数。在这个循环的主体中，创建一个新的外星人，并通过设置x 坐标将其加入当前行。将每个 外星人都往右推一个外星人的宽度。接下来，我们将外星人宽度乘以2，得到每个外星人占据的空间（其中包括其右边的空白区域）。

运行程序会看到：

【4】重构create_fleet()

game_function.py

def get_number_aliens_x(ai_settings, alien_width):
    # 计算每行可容纳多少个外星人
    avaliable_space_x = ai_settings.screen_width - 2 * alien_width
    number_aliens_x = int(avaliable_space_x / (2 * alien_width))
    return number_aliens_x

def create_alien(ai_settings, screen, aliens, alien_number):
    # 创建一个外星人并将其放在当前行
    alien = Alien(ai_settings, screen)
    alien_width = alien.rect.width  # 从外星人的rect 属性中获取外星人宽度
    alien.x = alien_width + 2 * alien_width * alien_number
    alien.rect.x = alien.x
    aliens.add(alien)


def create_fleet(ai_settings, screen, aliens):
    # 创建外星人群
    # 创建一个外星人，并计算一行可容纳多少个外星人
    # 外星人间距为外星人宽度
    alien = Alien(ai_settings, screen)
    number_aliens_x = get_number_aliens_x(ai_settings,alien.rect.width)

    # 创建第一行外星人
    for alien_number in range(number_aliens_x):
       create_alien(ai_settings, screen, aliens, alien_number)

【5】添加行

要创建外星人群，需要计算屏幕可容纳多少行，并对创建一行外星人的循环重复相应的次数。为计算可容纳的行数，计算可用垂直空间：将屏幕高度减去第一行外星人的上边距（外星人高度）、飞船的高度以及最初外星人群与飞船的距离（外星人高度的两倍）：

available_space_y = ai_settings.screen_height – 3 * alien_height – ship_height

每行下方都要留出一定的空白区域，并将其设置为外星人的高度。为计算可容纳的行数，将可用垂直空间除以外星人高度的两倍（同样，如果计算不对，可将间距调整为合理的值）。

number_rows = available_height_y / (2 * alien_height)

知道容纳多少行后，可重复执行创建一行的代码：

game_function.py

def get_number_row(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  # 从外星人的rect 属性中获取外星人宽度
    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_row(ai_settings, ship.rect.height,alien.rect.height)

    # 创建外星人群
    for row_number in range(number_rows):
        for alien_number in range(number_aliens_x):
            create_alien(ai_settings, screen, aliens, alien_number,row_number)

为嵌套循环，编写了一个新的for 循环。调用create_alien() 时，传递了一个表示行号的实参，将每行都沿屏幕依次向下放置。 create_alien() 的定义需要一个用于存储行号的形参。在create_alien() 中，修改外星人的y 坐标，并在第一行外星人上方留出与外星人等高的空白区 域。相邻外星人行的y 坐标相差外星人高度的两倍，因此我们将外星人高度乘以2，再乘以行号。第一行的行号为0，因此第一行的垂直位置不变，而其他行都沿屏幕依次向下放 置。

在create_fleet() 的定义中，还新增了一个用于存储ship 对象的形参，因此在alien_invasion.py中调用create_fleet() 时，需要传递实参ship ：

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

运行游戏可看到： 

4、让外星人群移动

目标：让外星人群在屏幕上向右移动，撞到屏幕边缘后下移一定的距离，再沿相反的方向移动。不断地移动所有的外星人，直到所有外星人都被消灭，有外星人撞上飞 船，或有外星人抵达屏幕底端。

【1】向右移动外星人

为移动外星人，将使用alien.py中的方法update() ，且对外星人群中的每个外星人都调用它。首先，添加一个控制外星人速度的设置：

setting.py

class Setting():
    # 存储该项目所有设置的类

    def __init__(self):
        # skip

        #外星人设置
        self.alien_speed_factor = 1 #外星人移动速度设置

alien.py

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

在主while 循环中已调用了更新飞船和子弹的方法，还需更新每个外星人的位置：

alien_invasion.py

  # 开始游戏的主循环
    while True:
        # 监视键盘和鼠标
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        gf.update_bullets(bullets)
        gf.update_aliens(aliens)
        gf.update_screen(ai_settings, screen, ship, aliens, bullets)

再更新子弹后再更新外星人的位置，因为稍后要检查是否有子弹撞到了外星人。

在文件game_functions.py末尾添加新函数update_aliens() ：

def update_aliens(aliens):
    # 更新外星人群中所有外星人的位置
    aliens.update()

运行游戏，看到外星人群向右移，并逐渐在屏幕右边缘消失。

【2】创建表示外星人移动方向的设置

创建让外星人撞到屏幕右边缘后向下移动、再向左移动的设置。

setting.py

  #外星人设置
        self.alien_speed_factor = 1  # 外星人移动速度设置
        self.fleet_drop_speed = 10   # 外星人群向下移动的速度
        # fleet_direction为1表示右移，-1表示为左移
        self.fleet_direction = 1

【3】检查外星人是否撞到了屏幕边缘

alien.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.ai_settings.alien_speed_factor * self.ai_settings.fleet_direction)
        self.rect.x = self.x

【4】向下移动外星人群并改变移动方向

有外星人到达屏幕边缘时，需要将整群外星人下移，并改变它们的移动方向。

需要对game_functions.py做重大修改，因为要在这里检查是否有外星人到达了左边缘或右边缘。编写函数check_fleet_edges() 和change_fleet_direction() ，并对update_aliens() 进行修改：

game_function.py

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 update_aliens(ai_settings, aliens):
    # 检查是否有外星人位于屏幕边缘，并更新外星人群中所有外星人的位置
    check_fleet_edges(ai_settings,aliens)
    aliens.update()

修改了函数update_aliens() ，在其中通过调用check_fleet_edges() 来确定是否有外星人位于屏幕边缘。现在，函数update_aliens() 包含形参ai_settings ，因此调用它时指定了与ai_settings 对应的实参：

alien_invasion.py

 # 开始游戏的主循环
    while True:
        # 监视键盘和鼠标
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        gf.update_bullets(bullets)
        gf.update_aliens(ai_settings,aliens)
        gf.update_screen(ai_settings, screen, ship, aliens, bullets)

运行程序，外星人在屏幕上来回移动，并在抵达屏幕边缘后向下移动：

5、射杀外星人

在游戏编程中，碰撞指的是游戏元素重叠在一起。要让子弹能够击落外星人，将使用sprite.groupcollide() 检测两个编组的成员之间的碰撞。

【1】检测子弹与外星人的碰撞

方法sprite.groupcollide() 将每颗子弹的rect 同每个外星人的rect 进行比较，并返回一个字典，其中包含发生了碰撞的子弹和外星人。在这个字典中，每个键都是一颗子弹，而相应的值都是被击中的外星人。

在函数update_bullets() 中，使用下面的代码来检查碰撞：

game_function.py

def update_bullets(aliens, bullets):
    """更新子弹的位置，并删除已消失的子弹"""
    # skip

    # 检查是否有子弹击中了外星人
    # 如果击中了，删除相应的子弹和外星人
    collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)

新增的这行代码遍历编组bullets 中的每颗子弹，再遍历编组aliens 中的每个外星人。每当有子弹和外星人的rect 重叠时，groupcollide() 就在它返回的字典中添加一 个键-值对。两个实参True 告诉Pygame删除发生碰撞的子弹和外星人。（要模拟能够穿行到屏幕顶端的高能子弹——消灭它击中的每个外星人，可将第一个布尔实参设置 为False ，并让第二个布尔实参为True 。这样被击中的外星人将消失，但所有的子弹都始终有效，直到抵达屏幕顶端后消失。）

调用update_bullets() 时，传递了实参aliens ：

alien_invasion.py

 # 开始游戏的主循环
    while True:
        # 监视键盘和鼠标
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        gf.update_bullets(aliens, bullets)
        gf.update_aliens(ai_settings,aliens)
        gf.update_screen(ai_settings, screen, ship, aliens, bullets)

现在运行程序，，被击中的外星人将消失：

【2】为测试创建大子弹

测试有些功能时，可以修改游戏的某些设置，以便专注于游戏的特定方面。例如，可以缩小屏幕以减少需要击落的外星人数量，也可以提高子弹的速度，以便能够在单位时间内发射大量子弹。或者将子弹设置为大子弹等等方式。

【3】生成新的外星人群

要在外星人群被消灭后又显示一群外星人，首先需要检查编组aliens 是否为空。如果为空，就调用create_fleet() 。在update_bullets() 中执行这种检查，因为外星人都是在这里被消灭的：

game_function.py

def update_bullets(ai_settings, screen, ship, aliens, bullets):
    """更新子弹的位置，并删除已消失的子弹"""
    # skip

    # 检查是否有子弹击中了外星人
    # 如果击中了，删除相应的子弹和外星人
    collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)

    if len(aliens) == 0:
        # 删除现有子弹并新建一群外星人
        bullets.empty()
        create_fleet(ai_settings, screen, ship, aliens)

更新alien_invasion.py中对update_bullets() 的调用：

 # 开始游戏的主循环
    while True:
        # 监视键盘和鼠标
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        gf.update_bullets(ai_settings, screen, ship, aliens, bullets)
        gf.update_aliens(ai_settings,aliens)
        gf.update_screen(ai_settings, screen, ship, aliens, bullets)

run_game()

【4】提高子弹的速度

为提高子弹的速度，可调整settings.py 中bullet_speed_factor 的值。

【5】重构update_bullets()

将把处理子弹和外星人碰撞的代码移到一个独立的函数中：

def update_bullets(ai_settings, screen, 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, ship, aliens, bullets)
  

def check_bullet_alien_collisions(ai_settings, screen, ship, aliens, bullets):
    # 响应子弹和外星人的碰撞
    # 删除发生碰撞的子弹和外星人
    collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)
    if len(aliens) == 0:
        # 删除现有子弹并新建一群外星人
        bullets.empty()
        create_fleet(ai_settings, screen, ship, aliens)

6、结束游戏

如果玩家没能在足够短的时间内将整群外星人都消灭干净，且有外星人撞到了飞船，飞船将被摧毁。与此同时，限制可供玩家使用的飞船数，而有外星人抵达屏幕底端时，飞船也将被摧毁。玩家用光了飞船后，游戏便结束。

【1】检测外星人和飞船碰撞

更新每个外星人的位置后立即检测外星人和飞船之间的碰撞。

def update_aliens(ai_settings, ship, aliens):
    # 检查是否有外星人位于屏幕边缘，并更新外星人群中所有外星人的位置
    check_fleet_edges(ai_settings,aliens)
    aliens.update()

    # 检测外星人和飞船之间的碰撞
    if pygame.sprite.spritecollideany(ship,aliens):
        print("Ship hit!!!")

方法spritecollideany() 接受两个实参：一个精灵和一个编组。它检查编组是否有成员与精灵发生了碰撞，并在找到与精灵发生了碰撞的成员后就停止遍历编组。在这里， 它遍历编组aliens ，并返回它找到的第一个与飞船发生了碰撞的外星人。 如果没有发生碰撞，spritecollideany() 将返回None 。

更新update_aliens() ：

alien_invasion.py

 # 开始游戏的主循环
    while True:
        # 监视键盘和鼠标
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        gf.update_bullets(ai_settings, screen, ship, aliens, bullets)
        gf.update_aliens(ai_settings, ship, aliens)
        gf.update_screen(ai_settings, screen, ship, aliens, bullets)

【2】响应外星人和飞船的碰撞

来编写一个用于跟踪游戏统计信息的新类——GameStats ，并将其保存为文件game_stats.py：

class GameStats():
    # 跟踪游戏的统计信息
    def __init__(self, ai_settings):
        # 初始化统计信息
        self.ai_settings = ai_settings
        self.reset_status()

    def reset_status(self):
        # 初始化在游戏运行期间可能变化的统计信息
        self.ship_left = self.ai_settings.ship_limit

一开始玩家拥有的飞船数存储在settings.py的ship_limit 中：

 #飞船的设置
        self.ship_speed_factor = 1.5   # 移动1.5px
        self.ship_limit = 3

对alien_invasion.py做些修改，以创建一个GameStats 实例：

# skip

from game_stats import  GameStats


def run_game():
    # skip

    pygame.display.set_caption("Alien Invasion")

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

    # 开始游戏的主循环
    while True:
        # skip
        gf.update_bullets(ai_settings, screen, ship, aliens, bullets)
        gf.update_aliens(ai_settings, stats, screen, ship, aliens,bullets)
        gf.update_screen(ai_settings, screen, ship, aliens, bullets)

run_game()

有外星人撞到飞船时，将余下的飞船数减1，创建一群新的外星人，并将飞船重新放置到屏幕底端中央（我们还将让游戏暂停一段时间，让玩家在新外星人群出现前注意到发生了碰撞，并将重新创建外星人群）。

下面将实现这些功能的大部分代码放到函数ship_hit() 中：

from time import sleep
#skip
def ship_hit(ai_settings, stats, screen, ship, aliens, bullets):
    # 响应被外星人撞到的飞船
    # 将ship_left件1
    stats.ship_left -= 1

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

    # 创建一群新外星人，并把飞船放到底部中央
    create_fleet(ai_settings,screen,ship,aliens)
    ship.center_ship()

    # 暂停
    sleep(0.5)


def update_aliens(ai_settings, stats, screen, ship, aliens, bullets):
    # 检查是否有外星人位于屏幕边缘，并更新外星人群中所有外星人的位置
    check_fleet_edges(ai_settings,aliens)
    aliens.update()

    # 检测外星人和飞船之间的碰撞
    if pygame.sprite.spritecollideany(ship,aliens):
        ship_hit(ai_settings, stats,screen, ship, aliens, bullets)

在ship.py添加方法center_ship()：

  def center_ship(self):
        # 让飞船在屏幕上居中
        self.centerx = self.screen_rect.centerx

【3】有外星人到达屏幕底端

如果有外星人到达屏幕底端，将像有外星人撞到飞船那样作出响应。

game_function.py

def check_aliens_bottom(ai_settings, stats, screen, 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, ship, aliens, bullets)
            break

def update_aliens(ai_settings, stats, screen, ship, aliens, bullets):
    # skip

    #检查是否有外星人到达了屏幕底部
    check_aliens_bottom(ai_settings, stats, screen, ship, aliens, bullets)

到达屏幕底端后，外星人的属性rect.bottom 的值大于或等于屏幕的属性rect.bottom 的值。

如果有外星人到达屏幕底端，就调用ship_hit() ；只要检测到一个外星人到达屏幕底端，就无需检查其他外星人，因此我们在调用ship_hit() 后退出循环。

每当有外星人撞到飞船或抵达屏幕底端时，都将出现一 群新的外星人。

【4】游戏结束

在GameStats 中添加一个作为标志的属性game_active ，以便在玩家的 飞船用完后结束游戏：

game_stats.py

class GameStats():
    # 跟踪游戏的统计信息
    def __init__(self, ai_settings):
        # skip

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

在在ship_hit() 中添加代码，在玩家的飞船都用完后将game_active 设置为False ：

game_function.py

def ship_hit(ai_settings, stats, screen, ship, aliens, bullets):
    # 响应被外星人撞到的飞船

    if stats.ship_left > 0:
        # 将ship_left件1
        stats.ship_left -= 1

        # skip
        # 暂停
        sleep(0.5)
    else:
        stats.game_active = False

7、确定应运行游戏的哪些部分

在alien_invasion.py中，需要确定游戏的哪些部分在任何情况下都应运行，哪些部分仅在游戏处于活动状态时才运行：

 # 开始游戏的主循环
    while True:
        # 监视键盘和鼠标
        gf.check_events(ai_settings,screen,ship,bullets)
        if stats.game_active:
            ship.update()
            gf.update_bullets(ai_settings, screen, ship, aliens, bullets)
            gf.update_aliens(ai_settings, stats, screen, ship, aliens,bullets)
        gf.update_screen(ai_settings, screen, ship, aliens, bullets)

运行程序：

8、小结

学习了：

• 如何在游戏中添加大量相同的元素，如创建一群外星人；
• 如何使用嵌套循环来创建元素网格，还通过调用每个元素的方法update() 移动了大量的元素；
• 如何控制对象在屏幕上移动的方向，以及如何响应事件，如有外星人到达屏幕边缘；
• 如何检测和响应子弹和外星人碰撞以及外星人和飞船碰撞；
• 如何在游戏中跟踪统计信息；
• 如何使用标志game_active 来判断游戏是否结束了。