python小游戏----外星人入侵

烟花落607

已于 2022-04-17 15:20:59 修改

阅读量5.9k

点赞数 26

文章标签： python

于 2022-04-17 13:09:01 首次发布

本文链接：https://blog.csdn.net/qq_61579824/article/details/124090681

版权

源代码：

AlienInvasion/game at main · CrashBugger/AlienInvasion (github.com)

本文来自作者对《python编程-从入门到实践》的学习记录，刚刚入门python,小白一个，若有错误，欢迎大佬指出。

图片资源：

just nobibi,show me the code!话不多说，开始项目。

1.创建pygame窗口响应用户输出

导包

import pygame
import sys
import settings

接下来

开始进行初步准备sssssssss

def run_game():
    # 初始化游戏并创建一个屏幕对象
    pygame.init()
    screen = pygame.display.set_mode((1200, 800))
    pygame.display.set_caption("Alien Invasion")
    # 游戏主循环
    while True:
        # 监视键盘和鼠标时间
        for event in pygame.event.get():
            if event == pygame.QUIT:
                sys.exit()
        # 让最近的绘制的屏幕可见
        pygame.display.flip()

其中pygame.init()方法初始化背景设置
pygame.display.set_mode()创建一个名为screen的窗口对象，以后我们将在这里面绘制图形元素，需要传入一个元组，表示窗口的长高。screen是一个surface对象
while循环控制游戏进行，for循环侦听事件，pygame.event.get()方法拿到事件列表，当检测到用户离开时，系统退出

display.flip()方法让最近绘制的屏幕可见

2.设置背景色

先上代码

def run_game():
    # 初始化游戏并创建一个屏幕对象
    pygame.init()
    screen = pygame.display.set_mode((1200, 800))
    pygame.display.set_caption("Alien Invasion")
    # shezhibeijingse
    bg_color = (230, 230, 230)

    # 游戏主循环
    while True:
        # 监视键盘和鼠标时间
        for event in pygame.event.get():
            if event == pygame.QUIT:
                sys.exit()
        # 每次循环重新绘制屏幕
        screen.fill(bg_color)
        # 让最近的绘制的屏幕可见
        pygame.display.flip()

创建一个元组bg_color存储RGB颜色，接下来在主循环中在screen中填充颜色，

3.创建设置类

这一步对前一步进行优化,创建一个settings类，用来保存我们的设置

class Settings():
    def __init__(self):
        self.screen_width = 1200
        self.screen_height = 800
        self.bg_color = (230, 230, 230)

接下来回到主方法创建这个类的实例进行设置

def run_game():
    # 初始化游戏，并创建一个屏幕对象
    pygame.init()
    ai_settings = settings.Settings()
    screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
    pygame.display.set_caption("Ailien Invasion")
    # bg_color = (230, 230, 230)
    while True:
        # 监听事件
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
        # 每次循环重置屏幕
        screen.fill(ai_settings.bg_color)
        # 最近绘制的屏幕可见
        pygame.display.flip()

4.创建ship类并绘制飞船

创建一个新的文件夹，命名为images,将ship.bmp放进去，接下来创建ship类

import pygame


class Ship():
    def __init__(self, screen):
        self.screen = screen
        # 加载飞船图像并获取外接矩形
        self.image = pygame.image.load("D:\PyCharm\Code\project\game\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)

pygame可以像处理矩形一样处理游戏元素，处理rect对象，可以使用矩形中心xy坐标和矩形四角
要将飞船显示在中央，需要设置rect对象的center,centerx或centery；如果要将飞船与边缘对其，可以设置其top,bottom,left,right属性；如果要调整坐标，需要设置其x,y属性，注意原点在左上角。
在主方法中加入飞船

def run_game():
    # 初始化游戏，并创建一个屏幕对象
    pygame.init()
    ai_settings = settings.Settings()
    screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
    pygame.display.set_caption("Ailien Invasion")
    # 创建一艘飞船
    ship = Ship(screen)
    while True:
        # 监听事件
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
        # 每次循环重置屏幕
        screen.fill(ai_settings.bg_color)
        ship.blitme()
        # 最近绘制的屏幕可见
        pygame.display.flip()

5.重构模块geme_functions

我们将游戏中的各个控制方法抽离到一个专门的模块
game_functions.py

import sys
import pygame
import ship

from game import settings


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


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

这些都是原本主循环中的方法，现在整合到一个模块

主方法在修改一下

先把刚创建的模块导包

import game_functions as gf

def run_game():
    # 初始化游戏，并创建一个屏幕对象
    pygame.init()
    ai_settings = settings.Settings()
    screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
    pygame.display.set_caption("Ailien Invasion")
    # 创建一艘飞船
    ship = Ship(screen)
    while True:
        # 监听事件
        gf.check_events()
        # 每次循环重置屏幕
        gf.update_screen(ai_settings, screen, ship)

6.驾驶飞船

先在ship类中新加一个属性moving_right=False，当检测到移动时，置位true，并新定义update方法，更新飞船位置

Ship类

    def __init__(self, screen):
        self.screen = screen
        # 加载飞船图像并获取外接矩形
        self.image = pygame.image.load("D:\PyCharm\Code\project\game\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

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

    def update(self):
        if self.moving_right:
            self.rect.centerx += 1

我们在game_functions.py的check_events方法中加入检测用户键盘的代码

game_functions.py

def check_events(ship: ship.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.type == pygame.KEYUP:
            if event.key == pygame.K_RIGHT:
                ship.moving_right = False

当用按下键盘时，我们在event检测其type属性，若为keydown，再进一步判断是否为向右键，并将ship类中的moving——righ属性置为true,当玩家抬起右键时，检测到keyup，将其置为false，

并在主方法中不断调用ship类的update方法

主方法

def run_game():
    # 初始化游戏，并创建一个屏幕对象
    pygame.init()
    ai_settings = settings.Settings()
    screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
    pygame.display.set_caption("Ailien Invasion")
    # 创建一艘飞船
    ship = Ship(screen)
    while True:
        # 监听事件
        gf.check_events(ship)
        # 更新
        ship.update()
        # 每次循环重置屏幕
        gf.update_screen(ai_settings, screen, ship)

7.调整飞船速度并限制飞船移动边界

在settings类中新加属性self.ship_speed_factor用于控制飞船速度
接下来在ship的方法init方法传入settings对象，并在update方法中用他的属性修改坐标，因为rect只存储整数部分的值，所以为了精细控制速度，我们用float方法返回rect.centerx保存到center属性，并在update方法对center修改，最后再用center覆盖centerx。
判断边界只需要在update方法中判断当前rect的left属性和right属性是否超出边界。

Ship类

class Ship():
    def __init__(self, screen, ai_settings: Settings):
        self.screen = screen
        # 加载飞船图像并获取外接矩形
        self.image = pygame.image.load("D:\PyCharm\Code\project\game\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
        # 飞船设置
        self.ai_settings = ai_settings
        # 在飞船的center属性中存储小数值
        self.center = float(self.rect.centerx)

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

    def update(self):
        # 加上边界判断
        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.rect.centerx = self.center

8.重构check_functions

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: ship.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)

提取出两个方法，如图

9.创建子弹类并加入编组

bullet.py

import pygame
from pygame.sprite import Sprite

from game.settings import Settings
from game.ship import Ship


class Bullet(Sprite):
    def __init__(self, ai_settings: Settings, screen, ship: 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.rect.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 update(self):
        """向上移动子弹"""
        # 更新y坐标
        self.y -= self.speed_factor
        # 覆盖
        self.rect.y = self.y

    def draw_bullet(self):
        """在屏幕上绘制子弹"""
        pygame.draw.rect(self.screen, self.color, self.rect)

我们继承sprite类，可以将子弹编组，同时操作编组中的元素。并传入settings对象ship对象和screen对象
用rect存储子弹矩形，并设置其centerx和top属性，让它与飞船相同
跟上一个相同的原因，我们用float（）精细调整子弹y坐标

我们在主方法导包并创建Group()实例，并将其传入while循环中的三个方法

from pygame.sprite import Group

# 初始化游戏，并创建一个屏幕对象
    pygame.init()
    ai_settings = settings.Settings()
    screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
    pygame.display.set_caption("Ailien Invasion")
    # 创建一艘飞船
    ship = Ship(screen, ai_settings)
    # 创建用于存储子弹的编组
    bullets = Group()
    while True:
        # 监听事件
        gf.check_events(ship, bullets)
        # 更新
        ship.update()
        # 更新子弹位置
        bullets.update()
        # 每次循环重置屏幕
        gf.update_screen(ai_settings, screen, ship, bullets)

编组的作用就是存储子弹，并且当调用update()方法时，自动对里面的每个子弹调用update方法，bullets.update()将被每颗子弹调用

10.Fire!开火

这里期望玩家按空格键可以完成开火
我们在functions对check_keydown方法加入对空格的判断若判断到，则在编组中新加入子弹;并在update_screen方法中重绘子弹，注意重绘子弹应在screen.flip（）方法调用之前
注意修改方法的参数

class Bullet(Sprite):
    def __init__(self, ai_settings: Settings, screen, ship: 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.rect.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 update(self):
        """向上移动子弹"""
        # 更新y坐标
        self.y -= self.speed_factor
        # 覆盖
        self.rect.y = self.y

    def draw_bullet(self):
        """在屏幕上绘制子弹"""
        pygame.draw.rect(self.screen, self.color, self.rect)

成功开火后，有个问题，那些飞出屏幕外的子弹，仍然留在内存中，这样越积越多，会让我们的游戏慢的龟爬一样，所以在主方法while循环中添加一个删除子弹的方法，判断子弹的bottom属性是否小于等于0，成立则从编组中删除掉

 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)
        # 每次循环重置屏幕
        gf.update_screen(ai_settings, screen, ship, bullets)

下来我们在对代码进行优化，创建update_bullets函数和fire_bullets来将原本开火和更新的代码抽离
games_functions.py

def update_bullets(bullets: Bullet):
    """更新子弹未位置"""
    # 更新位置
    bullets.update()
    # 删除已经消失的子弹
    for bullet in bullets.copy():
        if bullet.rect.bottom <= 0:
            bullets.remove(bullet)


def fire_bullets(ai_settings: Settings, screen: surface, ship: ship.Ship, bullets: Bullet):
    # 若子弹数量小于3，创建一颗新子弹,
    if len(bullets) < ai_settings.bullets_allowed:
        new_bullet = Bullet(ai_settings, screen, ship)
        bullets.add(new_bullet)

修改其中的keydown函数

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

11.创建外星人

我们首先改变一下游戏退出的方式，按下Q键即可退出,在game_functions.py中的key_down方法加上下面一条

    elif event.key == pygame.K_q:
        sys.exit(1)

创建外星人类

import pygame
from pygame import surface
from pygame.sprite import Sprite

from game.settings import Settings


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

    def __init__(self, ai_settings: Settings, screen: surface):
        # 初始化外星人并设置其起始位置
        super(Alien, self).__init__()
        self.screen = screen
        self.ai_settings = ai_settings
        # 加载外星人图像，设置其rect属性
        self.image = pygame.image.load(r"D:\PyCharm\Code\project\game\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类一样，不在赘述
接下来我们要将外星人在图像上画出来，需要在主方法中创建一个实例

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

并在game_functions中修改update_screen方法

game_functions.py

def update_screen(ai_settings: Settings, screen, ship: ship.Ship, alien: Alien, bullets: Bullet):
    """更新屏幕上的图像，并切换到新屏幕"""
    # 每次循环重绘屏幕
    screen.fill(ai_settings.bg_color)
    ship.blitme()
    # 绘制外星人
    alien.blitme()
    # 重绘子弹
    for bullet in bullets.sprites():
        bullet.draw_bullet()
    # 最近绘制的屏幕可见
    pygame.display.flip()

调用个blitme方法即可，注意还需要在flip方法调用之前
尝试成功，接下来我们要创建一行外星人
在game_functions.py中加入如下方法
在主方法中循环之前加入
```
# 创建外星人群
    aliens = Group()
    gf.create_fleet(ai_settings, screen, aliens)
```
aliens是一个空的编组，前面介绍过，编组可以对其中的每个元素调用方法，并将它传入create_fleet（）方法，这个方法在game_functions.py中定义
game_functions.py

def create_fleet(ai_settings: Settings, screen, aliens: Group):
    """创建外星人群"""
    # 创建一个外星人，并计算一行可以容纳多少个外星人
    alien: 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):
        newalien = Alien(ai_settings, screen)
        newalien.x = alien_width + 2 * alien_width * alien_number
        newalien.rect.x = newalien.x
        aliens.add(newalien)

首先计算一行可以容纳多少个外星人，间距我们设置为外星人的宽度，接下来在编组中加入新建的外星人

12.重构creat_fleet()

def create_fleet(ai_settings: Settings, screen, aliens: Group):
    """创建外星人群"""
    alien = Alien(ai_settings, screen)
    number_aliens_x = get_number_aliens(ai_settings, alien.rect.width, )
    for alien_number in range(number_aliens_x):
        create_alien(ai_settings, screen, aliens, alien_number)


def get_number_aliens(ai_settings: Settings, alien_width: int) -> int:
    """获取一行容纳的外星人数量"""
    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: Group, 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)

将其中的几个功能提取出来

13.添加多行外星人

game_functions.py

def get_number_rows(ai_settings: Settings, ship_height, alien_height) -> int:
    """计算能容纳多少行"""
    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: Settings, screen, ship: ship.Ship, aliens: Group):
    """创建外星人群"""
    alien = Alien(ai_settings, screen)
    number_aliens_x = get_number_aliens(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):
        for alien_row in range(number_rows):
            create_alien(ai_settings, screen, aliens, alien_number, alien_row)
def create_alien(ai_settings, screen, aliens: Group, alien_number, row_number):
    """创建一个外星人并放在当前行"""
    alien = Alien(ai_settings, screen)
    alien_width = alien.rect.width
    # 当前x
    alien.x = alien_width + 2 * alien_width * alien_number
    # 当前y
    alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
    alien.rect.x = alien.x
    aliens.add(alien)

修改create_fleet方法和create_alien方法
create_alien中加入一个参数row_number，表示当前应该添加到第几行，并据此修改y坐标
create_fleet方法中for循环新加一层层数循环

14.外星人移动

首先在settings.py中添加设置参数

settings.py

   # 外星人设置
        self.alien_speed_factor = 0.5#外星人水平移动速度
        self.fleet_drop_speed = 10#外星人竖直移动速度
        self.fleet_direction = 1  #移动方向： 1为向右，-1向左

Alien.py中加入下述代码

  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

game_functions.py中加入

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 check_fleet_edges(ai_settings: Settings, aliens):
    """有外星人到达边缘时采取相应的措施"""
    for alien in aliens.sprites():
        if alien.check_edges():
            change_fleet_direction(ai_settings, aliens)
            break


def update_aliens(ai_settings, aliens):
    """检查是否有外星人位于屏幕边缘，并更新调整外星人位置"""
    check_fleet_edges(ai_settings, aliens)
    aliens.update()

update_aliens为我们对主方法提供的接口，上面两个为辅助函数
主方法while中调用update_aliens方法

 # 更新aliens
        gf.update_aliens(ai_settings, aliens)

15.射杀外星人并生成新的外星人群

我们需要调用pygame.sprite.groupcollied方法，这个方法检测两个编组中的元素是否重合，重合的话进行处理,并返回一个字典，每个键值对为子弹-外星人。其中第一个True表示重合的话删除第一个编组中的元素，第二个true表示删除第二个编组中的元素。我们在更新子弹位置时调用这个方法，并增加主方法中的参数调用

击杀外星人后，我们需要判断是否需要生成新的外星人，若编组为空，重新调用生成外星人的方法
game_functions.py

def update_bullets(ai_settings, screen, ship, aliens: Alien, bullets: Sprite):
    """更新子弹未位置"""
    # 更新位置
    bullets.update()
    # 删除已经消失的子弹
    for bullet in bullets.copy():
        if bullet.rect.bottom <= 0:
            bullets.remove(bullet)
    check_bullet_alien_collision(ai_settings, screen, ship, aliens, bullets)


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

16.Boom！！！飞船与外星人相撞

如果飞船与外星人相撞或者外星人到底部，我们让游戏重置，重新生成外星人，并将飞船居中

ship.py

  def center_ship(self):
        """让飞船居中"""
        self.center = self.screen_rect.centerx

我们还需要将飞船的命数减一，为此我们新建一个GameStatus类，用于记录游戏状态信息
在Settings.py中新加属性
```
   self.ship_limit = 3
```

GameStatus.py

class GameStatus():
    """跟踪游戏的统计信息"""

    def __init__(self, ai_settings):
        """初始化统计的信息"""
        self.ai_settings = ai_settings
        self.reset_status()

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

game_functions.py

def update_aliens(ai_settings, stats, screen, ship, bullets, aliens):
    """检查是否有外星人位于屏幕边缘，并更新调整外星人位置"""
    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(aliens, ai_settings, stats, screen, ship, bullets)


def ship_hit(ai_settings: Settings, status: GameStatus, screen, ship: ship.Ship, aliens, bullets):
    """响应外星人撞到飞船"""
    # 将飞船数量ship_left减一
    status.ships_left -= 1
    # 清空外星人和子弹
    aliens.empty()
    bullets.empty()
    # 创建一群新的外星人，重置飞船
    create_fleet(ai_settings, screen, ship, aliens)
    ship.center_ship()
    # 暂停
    sleep(0.5)


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

我们调用update_aliens方法时，顺便检查一下飞船与外星人是否相撞，通过

pygame.sprite.spritecollideany(ship, aliens)

方法，第一个参数为一个飞船对象，第二个参数为一个编组，

17.游戏结束

game_functions.py的__ini__t中加入

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

这个属性让我们可以再玩家命数耗尽后置为False退出游戏。
改动game_functions.py方法，加入判断

def ship_hit(ai_settings: Settings, status: GameStatus, screen, ship: ship.Ship, aliens, bullets):
    """响应外星人撞到飞船"""
    # 将飞船数量ship_left减一
    if status.ships_left > 0:
        status.ships_left -= 1
        # 清空外星人和子弹
        aliens.empty()
        bullets.empty()
        # 创建一群新的外星人，重置飞船
        create_fleet(ai_settings, screen, ship, aliens)
        ship.center_ship()
        # 暂停
        sleep(0.5)
    else:
        status.game_active = False

主方法的while循环改为

 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)
            # 更新aliens
            gf.update_aliens(ai_settings, stats, screen, ship, bullets, aliens)
            # 每次循环重置屏幕
            gf.update_screen(ai_settings, screen, ship, aliens, bullets)

18.添加开始按钮

button.py

import pygame.font
class Button():
    def __init__(self, ai_settings: Settings, screen: Surface, 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)

font属性中我们调用pygame.font()方法，None表示用默认字体，48指的是字体字号。为了让按钮在屏幕居中，我们创建一个rect对象，并让他居中
接下来在新建一个方法prep_msg方法来处理按钮的渲染和绘制按钮的方法

    def prep_msg(self, msg):
        """将msg渲染为图像，并将其在按钮上居中"""
        self.msg_image = self.font.render(self, 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_button(self):
        """绘制一个用颜色填充的按钮，在绘制文本"""
        self.screen.fill(self.button_color, self.rect)
        self.screen.blit(self.msg_image, self.msg_image_rect)

其中的font.render方法将存储在msg中的文本转换为图像，并将其存储在msg_image中，其中的True参数表示开启抗锯齿功能，可以让文字边缘更光滑。接下来最后调通过rect调整按钮位置。
接下来draw_button来绘制按钮。
game_functions.py的update_screen中加入判断游戏活动状态的if语句，若不在活动状态，绘制一个按钮

def update_screen(ai_settings: Settings, screen, stats: GameStatus, ship: ship.Ship, aliens: Group, bullets: Bullet,
                  play_button: Button):
    """更新屏幕上的图像，并切换到新屏幕"""
    # 每次循环重绘屏幕
    screen.fill(ai_settings.bg_color)
    ship.blitme()
    # 绘制外星人
    aliens.draw(screen)
    # 重绘子弹
    for bullet in bullets.sprites():
        bullet.draw_bullet()
    if not stats.game_active:
        play_button.draw_button()
    # 最近绘制的屏幕可见
    pygame.display.flip()

主方法中创建按钮实例，并将其传入update_screen方法中

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

19.开始游戏或重置游戏

在game_functions.py中加入监视与按钮相关的鼠标事件

def check_events(ai_settings, screen, ship, bullets, stats: GameStatus, play_button: Button):
    """响应按键和鼠标事件"""
    for event in pygame.event.get():
        # 用户按下键盘
        if event.type == pygame.KEYDOWN:
            check_keydown_events(event, ai_settings, screen, ship, bullets)
        elif event.type == pygame.KEYUP:
            check_keyup_events(event, ship)
        elif event.type == pygame.K_SPACE:
            fire_bullets(ai_settings, )
        elif event.type == pygame.MOUSEBUTTONDOWN:
            # 若按下按钮
            mouse_x, mouse_y = pygame.mouse.get_pos()
            check_play_button(stats, play_button, mouse_x, mouse_y)
def check_play_button(stats: GameStatus, play_button: Button, mouse_x, mouse_y):
    """在玩家单击play时开始游戏"""
    if play_button.rect.collidepoint(mouse_x, mouse_y):
        stats.game_active = True

其中mouse.get_pos返回一个元组，表示鼠标点击的坐标，我们用play_button.rect.collidepoint方法判断是否与按钮坐标重合

接下来重置游戏，因为上面仅对第一次点击有用
再次修改check_lpay_button方法

def check_play_button(ai_settings, screen, stats: GameStatus, play_button: Button, mouse_x, mouse_y, aliens, ship,
                      bullets):
    """在玩家单击play时开始游戏"""
    if play_button.rect.collidepoint(mouse_x, mouse_y):
        # 重置游戏并统计信息
        stats.reset_status()
        stats.game_active = True
        # 清空外星人和子弹的列表
        bullets.empty()
        aliens.empty()
        # 创建外星人，并让飞船居中
        create_fleet(ai_settings, screen, ship, aliens)
        ship.center_ship()

我们新加了这个方法的参数，不要忘了在调用这个方法的位置加上（pycharm中ctrl+alt+h可以查看调用次方法的方法）

现在还是有个问题，如果玩家在点击按钮后再次点击，会出现再次重置的情况，所以我们再加入对stats.game_active的判断，同时再让点击后光标不可见

def check_play_button(ai_settings, screen, stats: GameStatus, play_button: Button, mouse_x, mouse_y, aliens, ship,
                      bullets):
    """在玩家单击play时开始游戏"""
    button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
    if button_clicked and not stats.game_active:
        #让光标不可见
        pygame.mouse.set_visible(False)
        # 重置游戏并统计信息
        stats.reset_status()
        stats.game_active = True
        # 清空外星人和子弹的列表
        bullets.empty()
        aliens.empty()
        # 创建外星人，并让飞船居中
        create_fleet(ai_settings, screen, ship, aliens)
        ship.center_ship()

修改ship_hit方法，让游戏重置时，鼠标可见

def ship_hit(ai_settings: Settings, status: GameStatus, screen, ship: ship.Ship, aliens, bullets):
    """响应外星人撞到飞船"""
    # 将飞船数量ship_left减一
    if status.ships_left > 0:
        status.ships_left -= 1
        # 清空外星人和子弹
        aliens.empty()
        bullets.empty()
        # 创建一群新的外星人，重置飞船
        create_fleet(ai_settings, screen, ship, aliens)
        ship.center_ship()
        # 暂停
        sleep(0.5)
    else:
        status.game_active = False
        pygame.mouse.set_visible(True)

20.加快游戏节奏

我们修改Settings.py中的属性来加快游戏

class Settings():
    def __init__(self):
        """  初始化游戏时的静态设置"""
        self.screen_width = 1200
        self.screen_height = 800
        self.bg_color = (230, 230, 230)
        # 飞船设置
        self.ship_speed_factor = 1.0
        self.ship_limit = 3
        # 子弹设置
        self.bullet_speed_factor = 0.7
        self.bullet_width = 3
        self.bullet_height = 15
        self.bullet_color = 60, 60, 60
        # 限制子弹数量
        self.bullets_allowed = 3
        # 外星人设置
        self.alien_speed_factor = 0.5  # 外星人水平移动速度
        self.fleet_drop_speed = 10  # 外星人竖直移动速度
        self.fleet_direction = 1  # 移动方向： 1为向右，-1向左
        # 以什么样的速度加快游戏节奏
        self.speedup_scale = 1.1
        self.initialize_dynamic_settings()

    def initialize_dynamic_settings(self):
        """初始化游戏进行而变化的设置"""
        self.ship_speed_factor = 1.5
        self.bullet_speed_factor = 3
        self.alien_speed_factor = 1
        self.fleet_direction = 1

    def increase_speed(self):
        """提高速度设置"""
        self.ship_speed_factor *= self.speedup_scale
        self.alien_speed_factor *= self.speedup_scale
        self.alien_speed_factor *= self.speedup_scale

增加了一个倍率属性和两个方法

def check_play_button(ai_settings: Settings, screen, stats: GameStatus, play_button: Button, mouse_x, mouse_y, aliens,
                      ship,
                      bullets):
    """在玩家单击play时开始游戏"""
    button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
    if button_clicked and not stats.game_active:
        #重置游戏节奏
        ai_settings.initialize_dynamic_settings()
         。。。。。。。。。。。。。。。。。。。。。。。

接下来修改

game_functions.py中的check_bullet_alien_collision

def check_bullet_alien_collision(ai_settings: Settings, screen, ship, aliens, bullets):
    # 检查是否有子弹击中外星人
    collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)
    # 更新外星人
    if len(aliens) == 0:
        bullets.empty()
        #增加游戏节奏
        ai_settings.increase_speed()
        create_fleet(ai_settings, screen, ship, aliens)

但是现在还有个问题，我们重置游戏时游戏节奏没有重置

def check_play_button(ai_settings: Settings, screen, stats: GameStatus, play_button: Button, mouse_x, mouse_y, aliens,
                      ship,
                      bullets):
    """在玩家单击play时开始游戏"""
    button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
    if button_clicked and not stats.game_active:
        #重置游戏节奏
        ai_settings.initialize_dynamic_settings()

21.计分

新增game_status.py中GameStatus类中的属性

    def reset_status(self):
        """初始化在游戏运行期间可能变化的信息"""
        self.ships_left = self.ai_settings.ship_limit
        self.score = 0

新建scoreboard.py模块，并创建Scoreboard类：

class Scoreboard():
    """显示得分信息的类"""

    def __init__(self, ai_settings: Settings, screen: Surface, status: GameStatus):
        """初始化得分涉及的属性"""
        self.screen = screen
        self.screen_rect = screen.get_rect()
        self.ai_settings = ai_settings
        self.status = status
        # 显示得分时的字体设置
        self.text_color = (30, 30, 30)
        self.font = pygame.font.SysFont(None, 48)
        # 准备初始得分图像
        self.prep_score()

    def prep_score(self):
        """将得分转换为渲染图像"""
        score_str = str(self.status.score)
        self.score_image = self.font.render(score_str, True, self.text_color)
        # 将得分显示在屏幕右上角
        self.score_rect = self.score_image.get_rect()
        self.score_rect.right = self.screen_rect.right - 20
        self.score_rect.top = 20

    def show_score(self):
        """在屏幕上显示得分"""
        self.screen.blit(self.score_image, self.score_rect)

22.创建记分牌

在主方法中循环前创建得分牌实例

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

并将其传入循环中的update_screen方法中

game_functions.py

def update_screen(ai_settings: Settings, screen, stats: GameStatus, ship: ship.Ship, aliens: Group, bullets: Bullet,
                  play_button: Button, sb: Scoreboard):
    """更新屏幕上的图像，并切换到新屏幕"""
    。。。。。。。。。。。。。。
    # 显示得分
    sb.show_score()
    # 最近绘制的屏幕可见
    pygame.display.flip()

接下来我们开始增加分数

settings.py中加入分数设置

    def initialize_dynamic_settings(self):
        """初始化游戏进行而变化的设置"""
        self.ship_speed_factor = 1.5
        self.bullet_speed_factor = 0.7
        self.alien_speed_factor = 0.7
        self.fleet_direction = 1
        # 计分
        self.alien_points = 50

game_functions.py中修改方法

def check_bullet_alien_collision(ai_settings: Settings, screen, ship, aliens, bullets, stats: GameStatus,
                                 sb: Scoreboard):
    # 检查是否有子弹击中外星人
    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()
    # 更新外星人
    if len(aliens) == 0:
        bullets.empty()
        # 增加游戏节奏
        ai_settings.increase_speed()
        create_fleet(ai_settings, screen, ship, aliens)

其中collisions是一个字典，我们拿到他的值，这个值是一个列表，其中包括我们一颗子弹打掉的全部飞船（不排除一箭双雕），所以求出列表长度来算分

不要忘了在形参中加入新的值并修改调用此方法传入的参数
接下来我们设置游戏难度提高后的点数
settings.py

class Settings():
    def __init__(self):
       。。。。。。。。。。。。。。
        # 点数提高速度
        self.score_scale = 1.5

    def increase_speed(self):
     。。。。。。。。。。。。。。
        """提高点数"""
        self.alien_points = int(self.alien_points * self.score_scale)

为了让记分牌跟以前那种街机风格的记分牌一样，每三位用“，”隔开，我们修改prep_score方法

scoreboard.py

    def prep_score(self):
        """将得分转换为渲染图像"""
        # 将得分圆整
        rounded_score = int(round(self.status.score, -1))
        score_str = "{:,}".format(rounded_score)
        # score_str = str(self.status.score)删去
        self.score_image = self.font.render(score_str, True, self.text_color)
        # 将得分显示在屏幕右上角
        self.score_rect = self.score_image.get_rect()
        self.score_rect.right = self.screen_rect.right - 20
        self.score_rect.top = 20

其中round（）中的-1表示我们向10取整

23.显示最高得分
scoreboard.py

 def __init__(self, ai_settings: Settings, screen: Surface, status: GameStatus):
        """初始化得分涉及的属性"""
       。。。。。。。。。。。。
        self.prep_high_score()

    def show_score(self):
        """在屏幕上显示得分"""
        。。。。。。。。。。。。。。。。。
        self.screen.blit(self.high_score_image, self.high_score_rect)

    def prep_high_score(self):
        """将最高得分转换为渲染的图像"""
        high_score = int(round(self.status.high_score, -1))
        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

接下来我们判断是否诞生了最高分

game_functions.py加入

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

我们需要在check_bullet_collision中调用分数判断

def check_bullet_alien_collision(ai_settings: Settings, screen, ship, aliens, bullets, stats: GameStatus,
                                 sb: Scoreboard):
    # 检查是否有子弹击中外星人
    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)
  。。。。。。。。。。。。。。。

24、显示等级

增加属性：

game_status.py

    def reset_status(self):
        """初始化在游戏运行期间可能变化的信息"""
       。。。。。。。。。。。。。
        self.level = 1

scoreboard.py

 def __init__(self, ai_settings: Settings, screen: Surface, status: GameStatus):
        """初始化得分涉及的属性"""
        。。。。。。。。。。。。。。。。
        self.prep_level()  
def show_score(self):
        """在屏幕上显示得分"""
       。。。。。。。。。。。。。。。。。。
        self.screen.blit(self.level_image, self.level_rect)
 def prep_level(self):
        """将等级渲染为图像"""
        self.level_image
        self.level_image = self.font.render(str(self.status.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

game_functions.py中修改

def check_bullet_alien_collision(ai_settings: Settings, screen, ship, aliens, bullets, stats: GameStatus,sb: Scoreboard):
   。。。。。。。。。。。。。。。。。。。。。。。。。
    # 更新外星人
    if len(aliens) == 0:
        bullets.empty()
        # 增加游戏节奏
        ai_settings.increase_speed()
        # 如果外星人都被消灭，就提高一个等级
        stats.level += 1
        sb.prep_level()
        create_fleet(ai_settings, screen, ship, aliens)

为了每次点击play按钮时重置记分牌，我们修改

def check_play_button(ai_settings: Settings, screen, stats: GameStatus, play_button: Button, mouse_x, mouse_y, aliens,
                      ship, bullets, sb: Scoreboard, ):
    """在玩家单击play时开始游戏"""
    ...........................................
        # 重置得分牌图像
        sb.prep_score()
        sb.prep_high_score()
        sb.prep_level()
        # 清空外星人和子弹的列表
        bullets.empty()
        aliens.empty()
        # 创建外星人，并让飞船居中
        create_fleet(ai_settings, screen, ship, aliens)
        ship.center_ship()

我们新传进来了个参数sb(ScoreBoard类)

25.显示剩余飞船
ship.py

class Ship(Sprite):
    def __init__(self, screen, ai_settings: Settings):
        """初始化飞船，并设置其起始位置"""
        super(Ship, self).__init__()
。。。。。。。。。。。。。。。。。。。。。。。。。。。。

让飞船继承sprite类，这样我们可以加入编组中管理

scoreboard.py类修改


class Scoreboard():
    """显示得分信息的类"""

    def __init__(self, ai_settings: Settings, screen: Surface, status: GameStatus):
        """初始化得分涉及的属性"""
        。。。。。。。。。。。。。。
        self.prep_ships()


    def show_score(self):
        """在屏幕上显示得分"""
      。。。。。。。。。。。。。。。。。。
        self.ships.draw(self.screen)



    def prep_ships(self):
        """显示还剩下多少飞船"""
        self.ships = Group()
        for ship_number in range(self.status.ships_left):
            ship = Ship(self.screen, self.ai_settings)
            ship.rect.x = 10 + ship_number * ship.rect.width
            ship.rect.y = 10
            self.ships.add(ship)

game_functions.py修改，调用prep_ships方法

def check_play_button(ai_settings: Settings, screen, stats: GameStatus, play_button: Button, mouse_x, mouse_y, aliens,
                      ship, bullets, sb: Scoreboard, ):
    """在玩家单击play时开始游戏"""
   。。。。。。。。。。。。。。。。。。
        # 重置得分牌图像
        sb.prep_score()
        sb.prep_high_score()
        sb.prep_level()
        sb.prep_ships()
        # 清空外星人和子弹的列表
        bullets.empty()
        aliens.empty()
        # 创建外星人，并让飞船居中
        create_fleet(ai_settings, screen, ship, aliens)
        ship.center_ship()

接下来我们在飞船撞到外星人时更新ships编组

def ship_hit(ai_settings: Settings, status: GameStatus, screen, ship: ship.Ship, aliens, bullets, sb: Scoreboard):
    """响应外星人撞到飞船"""
    # 将飞船数量ship_left减一
    if status.ships_left > 0:
        status.ships_left -= 1
        # 更新记分牌
        sb.prep_ships()
        。。。。。。。。。。。。。。。。。。

我们又加了一个sb参数，按ctrl+alt+h查看调用此方法的函数，依次修改函数形参

最终结果

完结撒花，本来没想到需要这么多字,打的我手疼（哭）。。。。没有辛劳也有苦劳，祝点赞的各位看官bug少少，头发多多~~~~

烟花落607

关注

26
点赞
踩
62

收藏

觉得还不错? 一键收藏
0
评论
python小游戏----外星人入侵

本文来自作者对《python编程-从入门到实践》的学习记录，刚刚入门python,小白一个，若有错误，欢迎大佬指出。图片资源：话不多说，开始项目,其中有些步骤是对前面的优化：1.创建pygame窗口响应用户输出导包import pygameimport sysimport settings接下来开始进行初步准备sssssssssdef run_game(): # 初始化游戏并创建一个屏幕对象 pygame.init() ...
复制链接

扫一扫