Pygame:外星人入侵

《python编程从入门到实践》（第二版）

 

实践项目1：pygame游戏：外星人入侵

文档说明：

        

游戏主文件夹:alien_invasion
项目规划:
    玩家控制一艘最初出现在屏幕底部中央的飞船
    操作说明:
        使用箭头键左右移动飞船
        使用空格键射击
    游戏开始时,一群外星人出现在天空中,并向屏幕下方移动,玩家的任务是射杀这些外星人
    玩家将所有外星人消灭干净后,将出现一群新的,并且移动速度更快
    只要有外星人撞到玩家的飞船或者到达屏幕底部,玩家就损失一条飞船
    玩家一共有三艘飞船

使用的第三方模块:pygame

.py文件说明:
    alien_invasion.py 游戏主控文件
    setting.py  设置类所在的模块
    ship.py  飞船类所在文件
    bullet.py 子弹类所在的文件
    alien.py 外星人类所在文件
    button.py 存放按钮的类
    game_stats.py 存放游戏统计信息的类

重构方法:
    在大型项目中,经常在添加新代码前重构既有代码,旨在简化既有代码结构,使其更容易扩展.
    本程序需要把越来越长run_game()拆分成一些辅助方法,
        辅助方法一般以单个下划线打头
        _check_events():事件循环
        _update_screen():更新屏幕

持续移动:
    设置移动标志:moving_left和moving_right
    在事件循环中仅改变移动标志
    在ship类中添加updata方法
    在run_game的主循环调用ship.update()
移动速度:
    在Settings类设置
    修改ship的update方法
    注意self.x 的目的是使得x属性能存储浮点数值

限制飞船的活动范围
    修改ship类的update()方法
    判断是否超出屏幕范围

重构_check_enents():
    将keydown和keyup的事件分开

按Q键退出:
    写入_check_keydown_events()

在全屏模式运行游戏
    修改主程序__init__

射击:
    按空格键发射子弹(用小矩形表示),子弹在屏幕中向上飞行,抵达边缘后消失
    为此新建一个bullet.py的文件

将子弹存储到编组中:
    在主程序中通过pygame.sprite.Group创建一个编组,用于管理所有发射出去的子弹
    对编组调用update()时,精灵自动对编组中的每一个对象调用update()
开火:
    在_check_keydown_events中编写按下空格键发射一颗子弹
    编写一个新的方法_fire_bullet()来完成这个任务

子弹的删除:
    游戏过程中,产生的子弹超出屏幕时,并没有消失.这将导致资源消耗
    在游戏主循环中删除超出范围的子弹
    使用self.bullet.rect.bottom<=0来判断是否超出屏幕范围
限制子弹数量:
    在settings中设置允许子弹的数量
    在创建子弹前先判断子弹数量是否小于设置值

创建方法_update_bullets()管理子弹代码,使得主程序的代码简洁

第二部分:外星人
    在屏幕左上角添加一个外星人,并指定合适的边距
    根据第一个外星人的边距和屏幕尺寸计算屏幕上可以容纳多少个外星人,编写一个循环来创建一系列外星人
    让外星人群向两边和下方移动,直到外星人撞到飞船或抵达屏幕下方
    如果外形人群全部被击落,再将创建一群外星人
    如果外星人撞到飞船或者抵达屏幕下方,玩家损失一搜飞船
    限制玩家飞船数量,飞船耗尽,游戏结束

新建文件alien.py,存储外星人类Alien
    Alien不需要在屏幕上绘制外星人的方法,而是通过pygame的编组方法,
    自动在屏幕上绘制编组中的所有元素
绘制一群外星人
    确定一行可以容纳多少个外星人
    available_space_x = settings.screen_width - (2*alien_width)
    让外星人之间空一个外星人的距离
    numbers_aliens_x = available_space_x //(2*alien_width)
    重写_create_fleet让其创建一群外星人
重构_create_fleet:
    添加_create_alien

添加行:
    计算能容纳几行外星人
    available_space_y = settings.screen_height - (3*alien_height) -ship_height
    number_rows = available_space_y // (2*alien_height)
让外星人移动
    让外星人向右移动,撞到屏幕边缘后下移一定的量,再沿相反的方向移动
检查外星人是否移动到了屏幕边缘
    check_edges()

向下移动外星人并改变方向
    编写方法_check_fleet_edges
            _change_fleet_direction
            修改_update_aliens

射杀外星人
    碰撞检测
        使用sprite.groupcollide()检测
        检测子弹和外星人的碰撞
            将子弹的rect和外星人的rect比较,并返回一个字典
            其中包含发生碰撞的子弹和外星人{子弹x:外星人y}
为测试创建大子弹
    修改设置
        如子弹速度,子弹大小等
生成新的外形人群
    在_update_bullets中增加
    如果aliens为空
    调用_create_fleet()来新增
重构_update_bullets
    将处理子弹和外星人碰撞的代码移动到一个独立的函数中_check_bullet_alien_collisions()

检测外星人和飞船碰撞
    在更新外星人后,立即检测外星人和飞船的碰撞
    所以代码加在_update_aliens()后面

新建类GameStats,用于跟踪游戏统计信息
新增方法_ship_hit()处理当外星人撞到飞船时做的事情
将新增方法放在_update_aliens(self)中
    同时新增ship类辅助方法center_ship(self)

有外星人到达屏幕底部:
    为检测这种情况,在主程序中添加 _check_aliens_bottom()方法

结束游戏:
    在GameStats中添加一个标志game_active
    当ships_left==0时结束游戏
    在_ship_hit()方法中改变标志game_active
    确定哪些部分在game_active为真状态下才运行

第三部分 记分
    添加play按钮
        在游戏开始前和结束后出现,用于玩家开始游戏
        修改状态信息类game_stats,开始时设置为false
        创建button类
        在屏幕上绘制按钮
            在主程序import中导入按钮类
            在__init__实例化一个按钮
            在_update_screen中绘制
        开始游戏
            在_check_events()添加代码块,监视与该按钮有关的鼠标事件
        重置游戏
            游戏因耗尽飞船结束时,应再次出现play按钮
            并重置统计信息,删除现有的外星人和子弹
            创建一群新的外星人并让飞船居中
        将play按钮切换到非活动状态
            游戏开始后虽然看不见paly按钮,但是鼠标点击那个位置还是会触发点击事件
            可以让游戏状态仅在false时才开始
        隐藏鼠标光标
            在_check_play_button添加代码
            游戏结束添加光标,在_ship_hit添加代码


    随着等级提高加快节奏,提升难度
        将设置分为静态设置和动态设置
        增加初始化速度和改变速度的方法
        在_check_bullet_alien_collisions()中调用设置的增加速度的方法increase_speed

        重置速度
        开始游戏时应该重置速度
        在方法_check_play_button添加代码

    记分系统
        实时跟踪玩家的得分,并显示最高得分,等级,剩余飞船数量
        在gameStats中添加score属性

        在屏幕上显示得分
            创建一个新类scoreboard
        创建记分牌
            在主程序创建一个scoreboard实例
            在_update_screen方法中绘制记分牌
        在外星人被消灭时更新得分
            在_check_bullet_alien_collisions添加代码

        调整外星人和子弹碰撞的方式,让每一个被消灭的外星人都能带来积分
        舍入得分

        最高得分
        将最高分存储在GameStats中

        显示等级

        显示剩余飞船数
bug:
    1.严格地来说应该叫做失误>>>
        在bullet.py中的update()方法中错误地将self.rect.y = self.y写成了
        self.rect = self.y导致绘制矩形的时候出现TypeError: rect argument is invalid

主文件：

alien_invasion.py

# alien_invasion.py
import sys
from time import sleep
import pygame
from settings import Settings
from game_stats import GameStats
from ship import Ship
from bullet import Bullet
from alien import Alien
from button import Button
from scoreboard import ScoreBoard

class AlienInvasion:
    '''管理游戏资源和行为的类'''

    def __init__(self):
        '''初始化游戏并创建游戏资源'''
        pygame.init()
        self.settings = Settings()
        # 全屏模式
        self.screen = pygame.display.set_mode((0,0),pygame.FULLSCREEN) # 全屏
        # self.screen = pygame.display.set_mode((self.settings.screen_width,self.settings.screen_height))  # surface
        self.settings.screen_width = self.screen.get_rect().width
        self.settings.screen_height = self.screen.get_rect().height
        pygame.display.set_caption('Alien Invasion')
        self.stats = GameStats(self)
        #创建记分牌
        self.scoreboard = ScoreBoard(self)
        self.ship = Ship(self)
        self.bullets = pygame.sprite.Group()
        self.aliens = pygame.sprite.Group()
        self._create_fleet()
        # 创建play按钮
        self.play_button = Button(self,'Play')


    def run_game(self):
        '''开始游戏的主循环'''
        while True:
            self._check_events()
            if self.stats.game_active:
                self.ship.update()
                self._update_bullets()
                self._update_aliens()
            self._update_screen()



    def _check_events(self):
        '''响应按键和鼠标事件'''
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                self._check_keydown_events(event)
            elif event.type ==pygame.KEYUP:
                self._check_keyup_events(event)
            elif event.type == pygame.MOUSEBUTTONDOWN:
                mouse_pos = pygame.mouse.get_pos()
                self._check_play_button(mouse_pos)

    def _check_play_button(self,mouse_pos):
        '''在玩家单击play时开始新游戏'''
        button_clicked = self.play_button.rect.collidepoint(mouse_pos)
        if button_clicked and not self.stats.game_active:
            # 重置速度
            self.settings.initialize_dynamic_settings()
            # 重置游戏统计信息
            self.stats.reset_stats()
            self.stats.game_active = True
            self.scoreboard.prep_score()
            self.scoreboard.prep_level()
            self.scoreboard.prep_ships()
            # 清空子弹和外星人
            self.aliens.empty()
            self.bullets.empty()
            # 创建新外星人,并让飞船居中
            self._create_fleet()
            self.ship.center_ship()
            # 隐藏鼠标光标
            pygame.mouse.set_visible(False)


    def _check_keydown_events(self,event):
        '''响应按键'''
        if event.key == pygame.K_RIGHT:
            self.ship.moving_right = True
        elif event.key == pygame.K_LEFT:
            self.ship.moving_left = True
        elif event.key == pygame.K_q:
            sys.exit()
        elif event.key == pygame.K_SPACE:
            self._fire_bullet()

    def _check_keyup_events(self,event):
        '''响应松开'''
        if event.key == pygame.K_RIGHT:
            self.ship.moving_right = False
        elif event.key == pygame.K_LEFT:
            self.ship.moving_left = False

    def _fire_bullet(self):
        '''创建一颗子弹并将其加入编组self.bullets中'''
        if len(self.bullets) <= self.settings.bullets_allowed:
            new_bullet = Bullet(self)
            self.bullets.add(new_bullet)

    def _update_bullets(self):
        '''更新子弹位置并删除消失的子弹'''
        # 更新子弹位置
        self.bullets.update()
        # 删除消失的子弹
        for bullet in self.bullets.copy():
            if bullet.rect.bottom <= 0:
                self.bullets.remove(bullet)
        # 检查是否有子弹击中了外星人
        # 如果是就删除相应的子弹和外星人
        self._check_bullet_alien_collisions()

    def _check_bullet_alien_collisions(self):
        '''响应子弹和外星人碰撞'''
        # 删除发生碰撞的子弹和外星人
        collisions = pygame.sprite.groupcollide(self.bullets, self.aliens, True, True)
        # 参数True指的是碰撞后删除碰撞的元素
        if collisions:
            for aliens in collisions.values():
                self.stats.score += self.settings.alien_points*len(aliens)
                # 重绘记分板
                self.scoreboard.prep_score()
                self.scoreboard.check_high_score()
        if not self.aliens:
            # 删除现有子弹并新建一群外星人
            self.bullets.empty()
            self._create_fleet()
            #加速
            self.settings.increase_speed()
            # 提高等级
            self.stats.level += 1
            self.scoreboard.prep_level()

    def _ship_hit(self):
        '''响应飞船被外星人撞到'''
        # 将ships_left 减1 并更新记分牌
        if self.stats.ships_left > 0:
            self.stats.ships_left -= 1
            self.scoreboard.prep_ships()
            # 清空余下的外星人和 子弹
            self.bullets.empty()
            self.aliens.empty()
            # 创建一群新的外星人并将飞船放到屏幕底部中央
            self._create_fleet()
            self.ship.center_ship()
            # 暂停
            sleep(0.5)
        else :
            self.stats.game_active = False
            # 恢复光标
            pygame.mouse.set_visible(True)




    def _update_aliens(self):
        '''检查是否有外星人位于边缘位置
        并更新整群外星人的位置 '''
        self._check_fleet_edges()
        self.aliens.update()
        # 检测外星人和飞船碰撞
        if pygame.sprite.spritecollideany(self.ship,self.aliens):
            # print('飞船被撞了!')  # 控制台打印,说明能检测到
            self._ship_hit()
        # 检查有否有外星人达到屏幕底部
        self._check_aliens_bottom()


    def _create_fleet(self):
        '''创建外星人群'''
        # 创建一个外星人并计算一行可以容纳多少个外星人
        alien = Alien(self)
        alien_width,alien_height = alien.rect.width,alien.rect.height
        available_space_x = self.settings.screen_width - (2 * alien_width)
        numbers_aliens_x = available_space_x // (2 * alien_width)
        # 计算屏幕可容纳几行外星人
        ship_height = self.ship.rect.height
        available_space_y = self.settings.screen_height - (3 * alien_height) - ship_height
        number_rows = available_space_y // (2 * alien_height)
        # 创建第一行外星人
        # for alien_number in range(numbers_aliens_x):
        #     self.__create_alien(alien_number)
        # 创建外星人群
        for row in range(number_rows):
            for alien_number in range(numbers_aliens_x):
                self.__create_alien(alien_number,row)

    def __create_alien(self,alien_number,row_number):
        # 创建一个外星人,并让其加入当前行
        alien = Alien(self)
        alien_width,alien_height = alien.rect.size
        alien.x = alien_width + 2 * alien_width * alien_number
        alien.rect.x = alien.x
        alien.y = alien.rect.height + 2*alien.rect.height*row_number
        alien.rect.y = alien.y
        self.aliens.add(alien)

    def _check_aliens_bottom(self):
        '''检测是否有外星人到达屏幕底部'''
        screen_rect = self.screen.get_rect()
        for alien in self.aliens.sprites():
            if alien.rect.bottom >= screen_rect.bottom:
                # 像飞船被撞到一样处理
                self._ship_hit()
                break




    def _check_fleet_edges(self):
        '''有外星人到达边缘时采取对应的措施'''
        for alien in self.aliens.sprites():
            if alien.check_edges():
                self._change_fleet_direction()
                break
    def _change_fleet_direction(self):
        '''对整群外星人下移并改变方向'''
        for alien in self.aliens.sprites():
            alien.rect.y += self.settings.fleet_drop_speed
        self.settings.fleet_direction *= -1




    def _update_screen(self):
        '''更新屏幕图像并切换到新屏幕'''
        self.screen.fill(self.settings.bg_color)
        self.ship.blitme()
        for bullet in self.bullets.sprites():
            bullet.draw_bullet()

        self.aliens.draw(self.screen)
        self.scoreboard.show_score()
        # 当游戏处于非活动状态,就绘制play按钮
        if not self.stats.game_active:
            self.play_button.draw_button()

        pygame.display.flip()



"""
说明:
    surface:是屏幕的一部分,用于显示游戏元素"""


if __name__ == '__main__':
    # 创建游戏实例并运行游戏
    ai = AlienInvasion()
    b = ai.settings
    print(b.bullet_height,b.bullet_width)
    ai.run_game()

飞船文件：

ship.py

# ship.py  飞船类所在文件
import pygame
from pygame.sprite import Sprite
class Ship(Sprite):
    '''管理飞船的类'''
    def __init__(self,ai_game):
        '''初始化飞船并设置其初始位置'''
        super().__init__()
        self.screen = ai_game.screen
        self.settings = ai_game.settings
        self.screen_rect = ai_game.screen.get_rect()
        # 加载飞船图像并获取其外接矩形
        self.image = pygame.image.load('images/ship.bmp')
        self.rect = self.image.get_rect()
        # 对于每艘新飞船,将其放置在屏幕底部中央
        self.rect.midbottom = self.screen_rect.midbottom
        # 让飞船的属性x能存储小数值
        self.x = float(self.rect.x)
        # 移动标志
        self.moving_right = False
        self.moving_left = False

    def update(self):
        '''根据移动标志调整飞船位置'''
        # 更新飞船而不是rect对象的x坐标
        if self.moving_right and self.rect.right < self.screen_rect.right:
            self.x += self.settings.ship_speed
        if self.moving_left and self.rect.left > self.screen_rect.left:
            self.x -= self.settings.ship_speed
        # 根据self.x更新rect对象
        self.rect.x = self.x


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

    def center_ship(self):
        '''让飞船在屏幕底部居中'''
        self.rect.midbottom = self.screen_rect.midbottom
        self.x = float(self.rect.x)

外星人：alien.py

# alien.py  外星人类所在文件
import pygame
from pygame.sprite import Sprite
class Alien(Sprite):
    '''表示单个外星人的类'''
    def __init__(self,ai_game):
        '''初始化外星人并设置其初始位置'''
        super().__init__()
        self.screen = ai_game.screen
        self.settings = ai_game.settings
        # 加载外星人图像并设置其rect属性
        self.image = pygame.image.load('images/alien.png')
        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 check_edges(self):
        '''如果外星人位于屏幕边缘就返回True'''
        screen_rect = self.screen.get_rect()
        if self.rect.right >= screen_rect.right \
            or self.rect.left <= 0:
            return True


    def update(self):
        '''向右移动外星人'''
        self.x += self.settings.alien_speed * self.settings.fleet_direction
        self.rect.x = self.x

子弹：bullet.py

import pygame
from pygame.sprite import Sprite
class Bullet(Sprite):
    '''管理飞船所发射的子弹的类'''
    def __init__(self,ai_game):
        '''在飞船当前位置创建一个子弹对象'''
        super().__init__()
        self.screen = ai_game.screen
        self.settings = ai_game.settings
        self.color = self.settings.bullet_color
        # 在(0,0)处创建一个表示子弹的矩形,再设置正确的位置
        self.rect = pygame.Rect(0,0,self.settings.bullet_width
                                ,self.settings.bullet_height)
        self.rect.midtop = ai_game.ship.rect.midtop
        # 存储小数表示的子弹位置
        self.y = float(self.rect.y)

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

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


"""
说明:
    pygame.sprite(精灵)可将游戏中的相关元素编组,进而同时操作编组中的元素
"""

设置:settings.py

# settings.py  设置类所在的模块
# 通过类Setting存储游戏所有的设置

class Settings:
    '''存储游戏<<外星人入侵>>中所有设置的类'''

    def __init__(self):
        '''初始化游戏的静态设置'''
        # 屏幕设置
        self.screen_width = 1200
        self.screen_height = 800
        self.bg_color = (230,230,230)
        # 飞船设置
        # self.ship_speed = 1.5
        self.ship_limit = 3
        # 子弹设置
        # self.bullet_speed = 3
        self.bullet_width = 3
        self.bullet_height = 15
        self.bullet_color = (60,60,60)
        self.bullets_allowed = 3
        # 外星人设置
        # self.alien_speed = 1.0
        self.fleet_drop_speed = 10
        # fleet_direction为1表示右移,-1表示左移
        # self.fleet_direction = 1
        # 加快游戏节奏
        self.speedup_scale = 1.1
        # 外星人分数的提高速度
        self.score_scale = 1.5
        self.initialize_dynamic_settings()

    def initialize_dynamic_settings(self):
        '''初始化随游戏进行而变化的设置'''
        self.ship_speed = 1.5
        self.bullet_speed = 3.0
        self.alien_speed = 1.0
        self.fleet_direction = 1
        # 消灭1个外星人的得分
        self.alien_points = 50

    def increase_speed(self):
        self.ship_speed *= self.speedup_scale
        self.bullet_speed *= self.speedup_scale
        self.alien_speed *= self.speedup_scale
        self.alien_points = int(self.alien_points * self.score_scale)
        # print(self.alien_points)

统计游戏过程信息

game_stats.py

class GameStats:
    '''跟踪游戏的统计信息'''
    def __init__(self,ai_game):
        '''初始化统计信息'''
        self.settings = ai_game.settings
        self.reset_stats()
        # 让游戏一开始处于非活动状态
        self.game_active = False
        # 任何情况下都不重置最高分
        self.high_score = 0



    def reset_stats(self):
        '''初始化在游戏运行期间可能变化的统计信息'''
        self.ships_left = self.settings.ship_limit
        self.score = 0
        self.level = 1

按钮:button.py

import pygame.font
class Button:
    def __init__(self,ai_game,msg):
        '''初始化按钮的属性'''
        self.screen = ai_game.screen
        self.screen_rect = self.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._pre_msg(msg)

    def _pre_msg(self,msg):
        '''将msg渲染为图像,并使其在按钮上居中'''
        self.msg_image = self.font.render(msg,True,self.text_color
                                          ,self.button_color)
        self.msg_image_rect = self.msg_image.get_rect()
        self.msg_image_rect.center = self.rect.center

    def draw_button(self):
        '''绘制一个用颜色填充的按钮,再绘制文本'''
        self.screen.fill(self.button_color,self.rect)
        self.screen.blit(self.msg_image,self.msg_image_rect)

记分板:socreboard.py

import pygame.font
from pygame.sprite import Group
from ship import Ship
class ScoreBoard:
    '''显示得分信息的类'''
    def __init__(self,ai_game):
        '''初始化显示得分涉及的属性'''
        self.ai_game = ai_game
        self.screen = ai_game.screen
        self.screen_rect = self.screen.get_rect()
        self.settings = ai_game.settings
        self.stats = ai_game.stats
        # 显示得分信息使用的字体的设置
        self.text_color = (30,30,30)
        self.font  = pygame.font.SysFont(None,48)

        # 准备包含最高的分和当前得分的图像
        self.prep_score()
        self.prep_high_score()
        # 显示等级
        self.prep_level()
        self.prep_ships()

    def prep_ships(self):
        '''显示还余下多少飞船'''
        self.ships = Group()
        for ship_number in range(self.stats.ships_left):
            ship = Ship(self.ai_game)
            ship.rect.x = 10 +ship_number * ship.rect.width
            ship.rect.y = 10
            self.ships.add(ship)

    def prep_level(self):
        '''将等级转换为渲染的图像'''
        level_str = str(self.stats.level)
        self.level_img = self.font.render(
            level_str,True,
            self.text_color,self.settings.bg_color)
        # 将等级放在等分下方
        self.level_rect = self.level_img.get_rect()
        self.level_rect.right = self.score_rect.right
        self.level_rect.top = self.score_rect.bottom + 10

    def prep_high_score(self):
        '''将最高等分渲染为图像'''
        high_score = round(self.stats.high_score,-1)
        high_score_str = '{:,}'.format(high_score)
        self.high_score_img = self.font.render(high_score_str,True,
                                               self.text_color,self.settings.bg_color)
        # 将最高分放在屏幕中央
        self.high_score_rect = self.high_score_img.get_rect()
        self.high_score_rect.centerx = self.screen_rect.centerx
        self.high_score_rect.top = self.score_rect.top

    def prep_score(self):
        '''将得分转化为一幅渲染的图像'''
        rounded_score = round(self.stats.score,-1)
        score_str = '{:,}'.format(rounded_score)
        self.score_img = self.font.render(score_str,True,
                                          self.text_color,self.settings.bg_color)
        # 在屏幕右上角显示得分
        self.score_rect = self.score_img.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_img,self.score_rect)
        self.screen.blit(self.high_score_img,self.high_score_rect)
        self.screen.blit(self.level_img,self.level_rect)
        self.ships.draw(self.screen)

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

效果:

---

 一个小游戏,玩的是你