Python项目 外星人入侵游戏

终于开始入门项目了，使用Pygame包，跟着教程的过程敲打游戏来学习，做了自己的笔记
文末有完整项目代码,或者点这 -->链接

目标

在游戏《外星人入侵》中，玩家控制着一艘最初出现在屏幕底部中央的飞船。玩家可以使用箭头键左右移动飞船，还可使用空格键进行射击。游戏开始时，一群外星人出现在天空中，他们在屏幕中向下移动。玩家的任务是射杀这些外星人。玩家将所有外星人都消灭干净后，将出现一群新的外星人，他们移动的速度更快。只要有外星人撞到了玩家的飞船或到达了屏幕底部，玩家就损失一艘飞船。玩家损失三艘飞船后，游戏结束。

环境

• 安装Pygame
  在Windows系统中用pip安装Pygame：
  在DOS界面输入：

python -m pip install --user pygame-1.9.2a0-cp35-none-win32.whl

即可安装

• 使用VS Code进行编写

开始

1.设置游戏环境

1.1 创建Pygame 窗口以及响应用户输入

首先，我们要创建一个空的Pygame窗口，在新文件夹中创建了window.py作为窗口文件。
然后使用Pygame编写的游戏的基本结构如下：

---

window.py

import sys
import pygame

def run_game():
    #初始化游戏并创建一个屏幕对象
    pygame.init()
    screen = pygame.display.set_mode((1200,800))#设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")#窗口名称

    #开始游戏的主循环
    while True:
        #监视键盘和鼠标事件
        for event in pygame.event.get():
            if event.type == pygame.QUIT:#检测玩家单击游戏窗口的关闭按钮，调用sys.exit()退出
                sys.exit()

        #让最近绘制的屏幕可见
        pygame.display.flip()

run_game()

• 对象screen是一个surface。在Pygame中， surface是屏幕的一部分，用于显示游戏元素。在这
  个游戏中，每个元素（如外星人或飞船）都是一个surface。 display.set_mode()返回的surface表
  示整个游戏窗口。我们激活游戏的动画循环后，每经过一次循环都将自动重绘这个surface。
• pygame.display.flip()，命令Pygame让最近绘制的屏幕可见。在这里，它在每次执行while循环时都绘制一个空屏幕，并擦去旧屏幕，使得只有新屏幕可见。在我们移动游戏元素时， pygame.display.flip()将不断更新屏幕，以显示元素的新位置，并在原来的位置隐藏元素，从而营造平滑移动的效果。

运行后生成空窗口，如下：

1.2 设置背景色

调用方法screen.fill()，用背景色填充屏幕

import sys
import pygame


def run_game():
    # 初始化游戏并创建一个屏幕对象
    pygame.init()
    screen = pygame.display.set_mode((1200,800))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

    # 设置背景色
    bg_color = (230,230,230)

    # 开始游戏的主循环
    while True:
        # 监视键盘和鼠标事件
        for event in pygame.event.get():
            if event.type == pygame.QUIT:# 检测玩家单击游戏窗口的关闭按钮，调用sys.exit()退出
                sys.exit()

        # 每次循环时都重绘屏幕
        screen.fill(bg_color)
        #让最近绘制的屏幕可见
        pygame.display.flip()

run_game()

1.3整合成类

每次给游戏添加新功能时，通常也将引入一些新设置。下面来编写一个名为settings的模块，其中包含一个名为Settings的类，用于将所有设置存储在一个地方，以免在代码中到处添加设置。这样，我们就能传递一个设置对象，而不是众多不同的设置。另外，这让函数调用更简单，且在项目增大时修改游戏的外观更容易：要修改游戏，只需修改settings.py中的一些值，而无需查找散布在文件中的不同设置。

首先新建文件命名为：settings.py

---

setting.py

class Settings():
    """存储所有设置的类"""

    def __init__(self):
        """初始化游戏的设置"""

        # 屏幕设置
        self.screen_width = 1200
        self.screen_height = 800
        self.bg_color = (230,230,230)

再把设置导入window.py中
window.py

import sys
import pygame

from settings import Settings

def run_game():
    # 初始化pygame、设置和屏幕对象
    pygame.init()
    ai_settings=Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width,ai_settings.screen_height))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

    # 设置背景色
    bg_color = (230,230,230)

    # 开始游戏的主循环
    while True:
        # 监视键盘和鼠标事件
        for event in pygame.event.get():
            if event.type == pygame.QUIT:# 检测玩家单击游戏窗口的关闭按钮，调用sys.exit()退出
                sys.exit()

        # 每次循环时都重绘屏幕
        screen.fill(ai_settings.bg_color)
        #让最近绘制的屏幕可见
        pygame.display.flip()

run_game()

2.添加飞船图像

下面将飞船加入到游戏中。为了在屏幕上绘制玩家的飞船，我们将加载一幅图像，再使用Pygame方法blit( )绘制它。
新建文件夹images，把下图右键复制到images中，命名ship.bmp

2.1创建ship类

选择用于表示飞船的图像后，需要将其显示到屏幕上。我们将创建一个名为ship的模块，其中包含Ship类，它负责管理飞船的大部分行为。

---

ship.py

import pygame

class Ship():
    
    def __init__(self,screen):
        """初始化飞船并设置其初始位置"""
        self.screen = screen

        # 加载飞船图像并获取其外接矩形
        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

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

• Ship的方法__init__()接受两个参数：引用self和screen，其中后者指定了要将飞船绘制到什么地方。为加载图像，我们调用了pygame.image.load()。这个函数返回一个表示飞船的surface，而我们将这个surface存储到了elf.image中。
• 处理rect对象时，可使用矩形四角和中心的x和y坐标。可通过设置这些值来指定矩形的位置
• 要将游戏元素居中，可设置相应rect对象的属性center、 centerx或centery。要让游戏元素与屏幕边缘对齐，可使用属性top、 bottom、 left或right；要调整游戏元素的水平或垂直位置，可使用属性x和y，它们分别是相应矩形左上角的x和y坐标。
• 我们将把飞船放在屏幕底部中央。为此，首先将表示屏幕的矩形存储在self.screen_rect中,再将self.rect.centerx（飞船中心的x坐标）设置为表示屏幕的矩形的属性centerx,并将self.rect.bottom（飞船下边缘的y坐标）设置为表示屏幕的矩形的属性bottom。 Pygame将使用这些rect属性来放置飞船图像，使其与屏幕下边缘对齐并水平居中。

2.2在屏幕上绘制飞船

接下来更新window.py，使其创建一艘飞船

---

window.py

import sys
import pygame

from settings import Settings
from ship import Ship

def run_game():
    # 初始化pygame、设置和屏幕对象
    pygame.init()
    ai_settings=Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width,ai_settings.screen_height))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

    # 设置背景色
    bg_color = (230,230,230)

    # 创建飞船
    ship = Ship(screen)
    # 开始游戏的主循环
    while True:
        # 监视键盘和鼠标事件
        for event in pygame.event.get():
            if event.type == pygame.QUIT:# 检测玩家单击游戏窗口的关闭按钮，调用sys.exit()退出
                sys.exit()

        # 每次循环时都重绘屏幕
        screen.fill(ai_settings.bg_color)
        ship.blitme()
        # 让最近绘制的屏幕可见
        pygame.display.flip()

run_game()

运行之后就有一艘小飞船啦

3.重构：模块game_functions

写到这里，window.py里的代码行越来越多，为方便理解逻辑，给window.py瘦身，创建一个名为game_functions的新模块，它将存储大量让游戏《外星人入侵》运行的函数。
首先把管理事件的代码移到一个名为check_events()的函数中，以简化run_game()并隔离事件管理循环。通过隔离事件循环，可将事件管理与游戏的其他方面（如更新屏幕）分离。

---

game_functions.py

import sys

import pygame

def check_events():
    """响应按键和鼠标事件"""
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()

def update_screen(ai_settings,screen,ship):
    """更新屏幕上的图像，并切换到新屏幕"""
    # 每次循环时都重绘屏幕
    screen.fill(ai_settings.bg_color)
    ship.blitme()
    # 让最近绘制的屏幕可见
    pygame.display.flip()

在window.py中就可以简化为相应函数：

import sys
import pygame

from settings import Settings
from ship import Ship
import game_functions as gf

def run_game():
    # 初始化pygame、设置和屏幕对象
    pygame.init()
    ai_settings=Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width,ai_settings.screen_height))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

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

    # 创建飞船
    ship = Ship(screen)
    # 开始游戏的主循环
    while True:
        gf.check_events()
        gf.update_screen(ai_settings,screen,ship)
        

run_game()

4.驾驶飞船

下面来让玩家能够左右移动飞船。

4.1响应按键

• 每当用户按键时，都将在Pygame中注册一个事件。事件都是通过方法pygame.event.get()获取的，因此在函数check_events()中，我们需要指定要检查哪些类型的事件。每次按键都被注册为一个KEYDOWN事件。
• 检测到KEYDOWN事件时，我们需要检查按下的是否是特定的键。例如，如果按下的是右箭头键，我们就增大飞船的rect.centerx值，将飞船向右移动
• 添加标志位：属性self.moving_right，并将其初始值设置为False，当按下右键，飞船就一直向右移动，松开就停止
• 在ship.py中添加方法update()检查标志moving_right的状态，如果这个标志为True，就调整飞船的位置。
• 如法炮制向左的按键

---

ship.py

import pygame

class Ship():
    
    def __init__(self,screen):
        """初始化飞船并设置其初始位置"""
        self.screen = screen

        # 加载飞船图像并获取其外接矩形
        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

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

    def update(self):
        """根据移动标志调整飞船的位置"""
        if self.moving_right:
            self.rect.centerx +=1
        if self.moving_left:
            self.rect.centerx -=1

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

game_functions.py

import sys

import pygame

def check_events(ship):
    """响应按键和鼠标事件"""
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_RIGHT:
                ship.moving_right = True
            elif event.key == pygame.K_LEFT:
                ship.moving_left = True

        elif event.type == pygame.KEYUP:
            if event.key == pygame.K_RIGHT:
                ship.moving_right = False
            elif event.key == pygame.K_LEFT:
                ship.moving_left = False

def update_screen(ai_settings,screen,ship):
    """更新屏幕上的图像，并切换到新屏幕"""
    # 每次循环时都重绘屏幕
    screen.fill(ai_settings.bg_color)
    ship.blitme()
    # 让最近绘制的屏幕可见
    pygame.display.flip()

window.py

import sys
import pygame

from settings import Settings
from ship import Ship
import game_functions as gf

def run_game():
    # 初始化pygame、设置和屏幕对象
    pygame.init()
    ai_settings=Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width,ai_settings.screen_height))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

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

    # 创建飞船
    ship = Ship(screen)
    # 开始游戏的主循环
    while True:
        gf.check_events(ship)
        ship.update()
        gf.update_screen(ai_settings,screen,ship)
        

run_game()

4.2调整飞船速度

• 在Settings类中添加属性ship_speed_factor，用于控制飞船的速度。

代码太长，就用snip跳过之前没改动的代码

---

settings.py

class Settings():
"""存储所有设置的类"""
def __init__(self):
	--snip--
	# 飞船的设置
	self.ship_speed_factor = 1.5

rect的centerx等属性只能存储整数值，因此我们需要对Ship类做些修改：

class Ship():
	def __init__(self, ai_settings, screen):
	"""初始化飞船并设置其初始位置"""
	self.screen = screen
	self.ai_settings = ai_settings
	--snip--
	# 在飞船的属性center中存储小数值
	self.center = float(self.rect.centerx)

def update(self):
	"""根据移动标志调整飞船的位置"""
	# 更新飞船的center值，而不是rect
	if self.moving_right:
		self.center += self.ai_settings.ship_speed_factor
	if self.moving_left:
		self.center -= self.ai_settings.ship_speed_factor

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

window.py

--snip--
def run_game():
	--snip--
	# 创建飞船
	ship = Ship(ai_settings, screen)

现在，只要ship_speed_factor的值大于1，飞船的移动速度就会比以前更快。这有助于让飞船的反应速度足够快，能够将外星人射下来，还让我们能够随着游戏的进行加快游戏的节奏

4.3限制飞船活动范围

当前，如果玩家按住箭头键的时间足够长，飞船将移到屏幕外面。

• 修改Ship类的方法update（）

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

4.4重构check_events()

老样子，随着游戏开发的进行，函数check_events()将越来越长，我们将其部分代码放在两个函数中：一个处理KEYDOWN事件，另一个处理KEYUP事件：

---

game_functions.py

import sys

import pygame

def check_keydown_events(event,ship):
    """响应按键"""
    if event.key == pygame.K_RIGHT:
        ship.moving_right = True
    elif event.key == pygame.K_LEFT:
        ship.moving_left = True

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 check_events(ship):
    """响应按键和鼠标事件"""
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        elif event.type == pygame.KEYDOWN:
            check_keydown_events(event,ship)
        elif event.type == pygame.KEYUP:
            check_keyup_events(event,ship)

def update_screen(ai_settings,screen,ship):
    """更新屏幕上的图像，并切换到新屏幕"""
    # 每次循环时都重绘屏幕
    screen.fill(ai_settings.bg_color)
    ship.blitme()
    # 让最近绘制的屏幕可见
    pygame.display.flip()

5.射击

下面来添加射击功能。我们将编写玩家按空格键时发射子弹（小矩形）的代码。子弹将在屏幕中向上穿行，抵达屏幕上边缘后消失。

5.1添加子弹设置

选择填在setting.py中，在__init__()末尾存储新类Bullet所需的值

---

settings.py

def __init__(self):
	--snip--
	# 子弹设置
	self.bullet_speed_factor = 1
	self.bullet_width = 3
	self.bullet_height = 15
	self.bullet_color = 60, 60, 60

这些设置创建宽3像素、高15像素的深灰色子弹。子弹的速度比飞船稍低.

5.2创建Bullet类

新建bullet.py

---

bullet.py

import pygame
from pygame.sprite import Sprite

class Bullet(Sprite):
    """一个对飞船发射子弹管理的类"""
    def __init__(self,ai_settings,screen,ship):
        """在飞船说出的位置创建一个子弹对象"""    
        super().__init__()
        self.screen = screen

        # 在（0，0）创建一个表示子弹的矩阵，再设置正确的位置
        self.rect = pygame.Rect(0,0,ai_settings.bullet_width,ai_settings.bullet_height)
        self.rect.centerx = ship.rect.centerx
        self.rext.top = ship.rect.top

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

        self.color = ai_settings.bullet_color
        self.speed_factor = ai_settings.bullet_speed_factor

    def uppdate(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)

• Bullet类继承了我们从模块pygame.sprite中导入的Sprite类。通过使用精灵，可将游戏中相关的元素编组，进而同时操作编组中的所有元素。为创建子弹实例，需要向__init__()传递ai_settings、 screen和ship实例，还调用了super()来继承Sprite。
• 我们创建了子弹的属性rect。子弹并非基于图像的，因此我们必须使用pygame.Rect()类从空白开始创建一个矩形。创建这个类的实例时，必须提供矩形左上角的x坐标和y坐标，还有矩形的宽度和高度。我们在(0, 0)处创建这个矩形，但接下来的两行代码将其移到了正确的位置，因为子弹的初始位置取决于飞船当前的位置。子弹的宽度和高度是从ai_settings中获取的。
• 子弹的颜色和速度设置分别存储到self.color和self.speed_factor中
• 方法update()管理子弹的位置。发射出去后，子弹在屏幕中向上移动，这意味着y坐标将不断减小，因此为更新子弹的位置，我们从self.y中减去self.speed_factor的值
• 属性speed_factor让我们能够随着游戏的进行或根据需要提高子弹的速度，以调整游戏的行为。子弹发射后，其x坐标始终不变，因此子弹将沿直
  线垂直地往上穿行。

5.3 将子弹存储到编组中

• 首先，在window.py中创建一个编组（ group），用于存储所有有效的子弹，以便能够管理发射出去的所有子弹。这个编组将是pygame.sprite.Group类的一个实例； pygame.sprite.Group类类似于列表，但提供了有助于开发游戏的额外功能。在主循环中，我们将使用这个编组在屏幕上绘制子弹，以及更新每颗子弹的位置：

---

window.py

import sys
import pygame
from pygame.sprite import Group

from settings import Settings
from ship import Ship
import game_functions as gf

def run_game():
    # 初始化pygame、设置和屏幕对象
    pygame.init()
    ai_settings=Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width,ai_settings.screen_height))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

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

    # 创建飞船
    ship = Ship(ai_settings,screen)
    # 创建一个用于存储子弹的编组
    bullets = Group()
    # 开始游戏的主循环
    while True:
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        bullets.update()
        gf.update_screen(ai_settings,screen,ship,bullets)
        

run_game()

5.4开火

• 在game_functions.py中，我们需要修改check_keydown_events()，以便在玩家按空格键时发射一颗子弹。我们无需修改check_keyup_events()，因为玩家松开空格键时什么都不会发生。我们还需修改update_screen()，确保在调用flip()前在屏幕上重绘每颗子弹。下面是对game_functions.py所做的相关修改：

---

game_functions.py

import sys
import pygame
from pygame.sprite import Group

from settings import Settings
from ship import Ship
import game_functions as gf

def run_game():
    # 初始化pygame、设置和屏幕对象
    pygame.init() 
    ai_settings=Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width,ai_settings.screen_height))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

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

    # 创建飞船
    ship = Ship(ai_settings,screen)
    # 创建一个用于存储子弹的编组
    bullets = Group()
    # 开始游戏的主循环
    while True:
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        bullets.update()
        gf.update_screen(ai_settings,screen,ship,bullets)
        

run_game()

• 编组bulltes传递给了check_keydown_events()。玩家按空格键时，创建一颗新子弹（一个名为new_bullet的Bullet实例），并使用方法add()将其加入到编组bullets中、代码bullets.add(new_bullet)将新子弹存储到编组bullets中。
• 我 们 给 在 屏 幕 上 绘 制 子 弹 的 update_screen() 添 加 了 形 参 bullets 。 方 法bullets.sprites()返回一个列表，其中包含编组bullets中的所有精灵。为在屏幕上绘制发射的所有子弹，我们遍历编组bullets中的精灵，并对每个精灵都调用draw_bullet()。

5.5删除已消失的子弹

当前，子弹抵达屏幕顶端后消失，这仅仅是因为Pygame无法在屏幕外面绘制它们。这些子弹实际上依然存在，它们的y坐标为负数，且越来越小。这是个问题，因为它们将继续消耗内存和处理能力。
我们需要将这些已消失的子弹删除，否则游戏所做的无谓工作将越来越多，进而变得越来越慢。为此，我们需要检测这样的条件，即表示子弹的rect的bottom属性为零，它表明子弹已穿过屏幕顶端：

---

window.py

--snip--
# 开始游戏的主循环
    while True:
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        bullets.update()

        #删除已消失的子弹
        for bullet in bullets.copy():
            if bullet.rect.bottom <=0 :
                bullets.remove(bullet)
        print(len(bullets))

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

• 在for循环中，不应从列表或编组中删除条目，因此必须遍历编组的副本。我们使用了方法copy()来设置for循环
• 使用了一条print语句，以显示当前还有多少颗子弹，从而核实已消失的子弹确实删除了
• 如果这些代码没有问题，我们发射子弹后查看终端窗口时，将发现随着子弹一颗颗地在屏幕顶端消失，子弹数将逐渐降为零。运行这个游戏并确认子弹已被删除后，将这条print语句删除
  
  

5.6限制子弹数量

很多射击游戏都对可同时出现在屏幕上的子弹数量进行限制，以鼓励玩家有目标地射击。

• 首先，在settings.py中存储所允许的最大子弹数：

---

settings.py

--snip--
# 子弹设置
self.bullet_width = 3
self.bullet_height = 15
self.bullet_color = 60, 60, 60
self.bullets_allowed = 3

这将未消失的子弹数限制为3颗。在game_functions.py的check_keydown_events()中，我们在创建新子弹前检查未消失的子弹数是否小于该设置：

def check_keydown_events(event, ai_settings, screen, ship, bullets):
   --snip--
	# 创建一颗子弹，并将其加入到编组bullets中
	if len(bullets) < ai_settings.bullets_allowed:
		new_bullet = Bullet(ai_settings, screen, ship)
		bullets.add(new_bullet)

5.7重构

再瘦身

• 把window.py中删除已消失的子弹代码移动到game_functions.py中，命名为update_bullets()
• 创建函数 fire_bullet()，把发射子弹的代码移到一个fire_bullet函数中，这样，在check_keydown_events()中只需使用一行代码来发射子弹，让elif代码块变得非常简单

---

game_functions.py

import sys

import pygame
from bullet import Bullet

def check_keydown_events(event, ai_settings, screen, 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:
        fire_bullet(ai_settings, screen, ship, bullets)
        

def fire_bullet(ai_settings, screen, ship, bullets):
    """如果还没有到达限制，就发射一颗子弹"""
    # 创建一颗子弹，并将其加入到编组bullets中
    if len(bullets) < ai_settings.bullets_allowed:
        new_bullet = Bullet(ai_settings, screen, ship)
        bullets.add(new_bullet)

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 check_events(ai_settings, screen, ship, bullets):
    """响应按键和鼠标事件"""
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        elif event.type == pygame.KEYDOWN:
            check_keydown_events(event, ai_settings, screen, ship, bullets)
        elif event.type == pygame.KEYUP:
            check_keyup_events(event,ship)

def update_screen(ai_settings, screen, ship, bullets):
    """更新屏幕上的图像，并切换到新屏幕"""
    # 每次循环时都重绘屏幕
    screen.fill(ai_settings.bg_color)
    # 在飞船和外星人后面重绘所有子弹
    for bullet in bullets.sprites():
        bullet.draw_bullet()
    ship.blitme()
    # 让最近绘制的屏幕可见
    pygame.display.flip()

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

    #删除已消失的子弹
    for bullet in bullets.copy():
        if bullet.rect.bottom <=0 :
            bullets.remove(bullet)
            

window.py

--snip--
while True:
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        gf.update_bullets(bullets)
        gf.update_screen(ai_settings,screen,ship,bullets)

6.创建外星人

6.1选一个合适的敌人

右键另存为alien.bmp到images

6.2创建 Alien 类

• 新建alien.py

---

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类相似。每个外星人最初都位于屏幕左上角附近，将每个外星人的左边距都设置为外星人的宽度，并将上边距设置为外星人的高度
在window.py中创建实例

---

window.py

--snip--
from ship import Ship
from alien import Alien
import game_functions as gf
def run_game():
	--snip--
	# 创建一个外星人
	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()

而后在game_functions.py中函数update_screen()调用其方法blitme()：
game_functions.py

def update_screen(ai_settings, screen, ship, alien, bullets):
	--snip--
	ship.blitme()
	alien.blitme()

6.3创建多个敌人

*alien_invasion.py

def run_game():
	--snip--
    # 创建一艘飞船、一个子弹编组和一个外星人编组
    ship = Ship(ai_settings,screen)
    bullets = Group()
    aliens = Group()
    # 创建外星人群
    gf.create_fleet(ai_settings, screen, aliens)
    # 开始游戏主循环
	while True:
		--snip—
		gf.update_screen(ai_settings, screen, ship, aliens, bullets)

在game_functions.py末尾创建函数create_fleet()

game_functions.py

from alien import Alien
--snip--

def create_fleet(ai_settings, screen, aliens):
    """创建外星人群"""
    # 创建一个外星人，并计算一行可容纳多少个外星人
    # 外星人间距为外星人宽度
    alien = Alien(ai_settings, screen)
    alien_width = alien.rect.width
    available_space_x = ai_settings.screen_width - 2 * alien_width
    number_aliens_x = int(available_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)

6.4重构create_fleet()

下面是create_fleet()和两个新函数， get_number_aliens_x()和create_alien()：

---

game_functions.py

--snip--
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 create_alien(ai_settings, screen, aliens, alien_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
    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)

6.5添加行

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

available_space_y = ai_settings.screen_height – 3 * alien_height – ship_height

这将在飞船上方留出一定的空白区域，给玩家留出射杀外星人的时间。
每行下方都要留出一定的空白区域，并将其设置为外星人的高度。为计算可容纳的行数，我们将可用垂直空间除以外星人高度的两倍（同样，如果这样的计算不对，我们马上就能发现，继而将间距调整为合理的值）

number_rows = available_height_y / (2 * alien_height)

然后把公式添加到game_functions.py中

---

game_functions.py

--snip--
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 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_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 row_number in range(number_rows):
        for alien_number in range(number_aliens_x):
            create_alien(ai_settings,screen,aliens,alien_number,row_number)

然后再window.py中修改gf.create_fleet()的值：

window.py

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

这时候运行就有一群敌人

7.移动外星人

7.1向右移动

• 在settings.py末尾添加：
  settings.py

# 外星人设置
self.alien_speed_factor = 1

然后，使用这个设置来实现update()：
alien.py

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

最后在window.py中调用函数：

window.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()：

game_functions.py

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

7.2创建表示外星人移动方向的设置

在settings.py中加入：
settings.py

# 外星人设置
self.alien_speed_factor = 1
self.fleet_drop_speed = 10
# fleet_direction为1表示向右移，为-1表示向左移
self.fleet_direction = 1

设置fleet_drop_speed指定了有外星人撞到屏幕边缘时，外星人群向下移动的速度。将这个速度与水平速度分开是有好处的，这样你就可以分别调整这两种速度了。
要实现fleet_direction设置，可以将其设置为文本值，如’left’或’right’，但这样就必须编写if-elif语句来检查外星人群的移动方向。鉴于只有两个可能的方向，我们使用值1和-1来表示它们，并在外星人群改变方向时在这两个值之间切换。另外，鉴于向右移动时需要增大每个外星人的x坐标，而向左移动时需要减小每个外星人的x坐标，使用数字来表示方向更合理。

7.3检查外星人是否撞到了屏幕边缘

alien.py

import pygame
from pygame.sprite import Sprite

class Alien(Sprite):
    """表示单个外星人的类"""
    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 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

7.4向下移动外星人群并改变移动方向

有外星人到达屏幕边缘时，需要将整群外星人下移，并改变它们的移动方向。我们需要对game_functions.py做重大修改，因为我们要在这里检查是否有外星人到达了左边缘或右边缘。为此，我们编写函数check_fleet_edges()和change_fleet_direction()，并对update_aliens()进行修改：

---

game_functions.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()

同时在window.py中引用函数：
window.py

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

8.射杀

8.1检测子弹与外星人的碰撞

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

更新game_functions.py中update_bullets（）：

---

game_functions.py

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

    #删除已消失的子弹
    for bullet in bullets.copy():
        if bullet.rect.bottom <=0 :
            bullets.remove(bullet)
    
    # 检查是否有子弹击中了外星人
    # 如果是这样，就删除相应的子弹和外星人
    collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)

同样在window.py中也同步更新gf.update_bullets(aliens,bullets)

此时实现子弹击落的效果：

8.2刷怪

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

---

game_functions.py

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

    #删除已消失的子弹
    for bullet in bullets.copy():
        if bullet.rect.bottom <=0 :
            bullets.remove(bullet)
    
    # 检查是否有子弹击中了外星人
    # 如果是这样，就删除相应的子弹和外星人
    collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)

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

同步再window.py上更新gf.update_bullets(ai_settings, screen, ship, aliens, bullets)

8.3提高子弹速度

在settings.py中修改self.bullet_speed_factor即可

8.4重构 update_bullets()

game_functions.py

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)

9.结束游戏

9.1检测外星人和飞船碰撞

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

---

game_stats.py

class GameStats():
    """跟踪游戏的统计信息"""
    def __init__(self, ai_settings):
        """初始化统计信息"""
        self.ai_settings = ai_settings
        self.reset_stats()
        
    def reset_stats(self):
        """初始化在游戏运行期间可能变化的统计信息"""
        self.ships_left = self.ai_settings.ship_limit

更新window.py中的gf.update_aliens(ai_settings, ship, aliens)

9.2响应外星人和飞船碰撞

代码过长，以下就略过，所有文件会在最后放出来

• 在settings.py中添加self.ship_limit = 3，设置为3条命
• 来 编 写 一 个 用 于 跟 踪 游 戏 统 计 信 息 的 新 类 ——GameStats ， 并 将 其 保 存 为 文 件game_stats.py：
• 在window.py中创建一个GameStats实例
• 更新了update_aliens()的定义，使其包含形参stats、 screen和bullets，让它能够在调用ship_hit()时传递这些值

9.3有外星人到达屏幕底端

• 如果有外星人到达屏幕底端，我们将像有外星人撞到飞船那样作出响应。
• game_functions.py中添加

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)

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

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

9.4结束游戏

game_stats.py

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

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

    def reset_stats(self):
        """初始化在游戏运行期间可能变化的统计信息"""
        self.ships_left = self.ai_settings.ship_limit
        ```
最后在window.py和game_functions.py添加条件
*game_functions.py*

```python
def ship_hit(ai_settings, stats, screen, ship, aliens, bullets):
	"""响应飞船被外星人撞到"""
	if stats.ships_left > 0:
		# 将ships_left减1
		stats.ships_left -= 1
		--snip--
		#暂停一会儿
		sleep(0.5)
	else:
		stats.game_active = False

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)

10.记分

添加了记分、最高分和等级记录显示

最终效果：

完整代码下载

• 运行window.py就能打开窗口了。