《python编程：从入门到实践》外星人入侵小游戏

写此片blog的主要目的在于回顾游戏敲写过程，为了能更好的记录编写过程，如能对您稍微有点帮助，倍感荣幸。

此游戏几乎都是按照《python编程：从入门到实践》中的代码敲写，有几个参数（比如游戏窗口大小）的数值更改了一下。游戏代码敲完后，想要打包来着，无奈打包后的程序运行不了，笔者不才，百度后依然未能解决，决定先缓一缓，继续学习，过段时间再试，代码功能实现的具体步骤如下（即压缩包文件中（转下几行链接）alien_invasion_execute_record.py；；；最终的主功能代码为文件alien_invasionV37.py[包括调用的settingsV9；game_statsV5；scoreboardV3；shipV6；game_functionsV32]）
ps:各模块功能的逐步实现在该模块中有较为详细的记录，只是文件名不同，模块中定义函数及其功能相同。
（本想上传包含各功能代码的压缩包，无奈审核未通过，那，，，那就曲线救国吧，压缩包百度网盘链接https://pan.baidu.com/s/1plgMkX5ms-IqXgXNd3J4-g）

1.主功能代码

#alien_invasionV37.py
#调整飞船的速度后的更改
#限制飞船的活动范围
#将子弹存储到编组中，故创建列表
#对game_functionsV13的调用,创建外星人群
#更新每个外星人的位置
#向下移动外星人群，并改变移动方向，整群下移，改变方向，左右移V15
#外星人群消灭后，生成新的外星人群
#重构update_bullets()，将处理子弹和外星人的碰撞的代码移动到一个独立的函数中

#检查外星人和飞船之间的碰撞,调用V19
#创建一个GameStats实例
#响应外星人与飞船的碰撞
#有外星人到达屏幕低端，做出类似碰撞的响应V21
#根据标志的属性game_active确定运行游戏的哪些部分
#在屏幕上绘制按钮
#调用V25玩家单击play按钮时重置游戏（三艘飞船）
#仅当玩家点击了play按钮且游戏当前处于非活动状态时，游戏才重新开始并在游戏开始后隐藏光标V26
#在整群外星人都被消灭后调用函数加快游戏节奏，
#在创建一群新的外星人,,并在开始新游戏时重置速度V27 V7
#创建sb实例以显示得分
#修改update_bullets（子弹碰撞，计分）更新得分，将消灭的每个外星人的点数都计入得分V29
#在游戏开始时刷新剩余飞船数并在飞船被撞到时调用prep_ships()，减少飞船图像V32，V3
'''检查是否诞生了新的最高得分（及时更新最高得分）在检测碰撞中提高等级，并更新图像等级
; 为确保在开始游戏时更新计分和等级图像，在按钮play被单击时触发重置V31'''

'''创建一行外星人->创建一个名为aliens的空编组,
用于存储全部的外星人,再调用game_functions.py
中创建外星人群的函数'''



'''修改while循环，以便每次执行循环时都调用
飞船的方法update()'''

import pygame 
from pygame.sprite import Group

from settingsV9 import Settings
from game_statsV5 import GameStats
from scoreboardV3 import Scoreboard
from button import Button

from shipV6 import Ship
import game_functionsV32 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')
    
    #创建Play按钮
    play_button = Button(ai_settings, screen, 'Play')
    
    #创建一个用于存储游戏统计信息的实例,并创建记分牌
    stats = GameStats(ai_settings)
    sb = Scoreboard(ai_settings, screen, stats)
    #创建一艘飞船，一个子弹编组和一个外星人编组
    ship = Ship(ai_settings, screen)
    bullets = Group()
    aliens = Group()
    
    #创建外星人群
    gf.create_fleet(ai_settings, screen, ship, aliens)
    
    #开始游戏主循环
    while True:
        #调用事件管理循环
        gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
                        aliens, bullets)
        
        if stats.game_active:
                
            ship.update()
            gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens, bullets)
            gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens, bullets)
      
      
        #调用屏幕更新函数
        gf.update_screen(ai_settings, screen, stats, sb, ship, aliens,
                bullets, play_button)
        
run_game()

2.游戏功能模块调用与实现

#game_functionsV32.py
#将更新屏幕的代码移到game_functions中
#响应按键（右移）增加左移命令
#将check_events()简化处理->两个函数

#修改check_keydown_events()->按下空格发出子弹
#修改update_screen()确保在调用flip()前在屏幕上重绘子弹
#将发射子弹的代码移到一个独立的函数中
#添加一个结束游戏的快捷键Q:
#让外星人出现在屏幕上
#创建外星人群的函数，修改对update_screen()的调用->能够访问外星人编组
#重构create_fleet()  并添加行
#添加更新外星人的函数
#向下移动外星人群，并改变移动方向，整群下移，改变方向，左右移
#检测子弹与外星人的碰撞，更新子弹位置之后检测
#外星人群消灭后，生成新的外星人群
#重构update_bullets()，将处理子弹和外星人的碰撞的代码移动到一个独立的函数中
#检查外星人和飞船之间的碰撞
#添加ship_hit()函数
#有外星人到达屏幕低端，做出类似碰撞的响应
#在ship_hit()中添加代码，使玩家飞船用完后将game_active设置为False
#修改update_screen在屏幕更新时显示按钮
#玩家单击play按钮时开始游戏，
#玩家单击play按钮时重置游戏（三艘飞船）
#仅当玩家点击了play按钮且游戏当前处于非活动状态时，游戏才重新开始并在游戏开始后隐藏光标
#在整群外星人都被消灭后调用函数加快游戏节奏，在创建一群新的外星人,,并在开始新游戏时重置速度
#修改update_screen使其能够显示得分
#每当有外星人被击落时，更新得分，调用prep_score来创建一幅显示最新得分的新图像
#将消灭的每个外星人点数都计入得分
#检查是否诞生了新的最高得分（及时更新最高得分）
#在检测碰撞中提高等级，并更新图像等级; 为确保在开始游戏时更新计分和等级图像，在按钮play被单击时触发重置
#在游戏开始时刷新剩余飞船数并在飞船被撞到时调用prep_ships()，减少飞船图像
'''对编组调用draw时，Pygame自动绘制编组中的每个元素
    ，绘制位置由元素的属性rect决定，这里，aliens.draw(screen)
    在屏幕上绘制编组中的每个外星人'''


'''修改check_events()，使玩家按下右箭头键
时将moving_right设置为True,松开时设置为False'''

import sys , pygame
from bullet import Bullet
from time import sleep
from alienV2 import Alien



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_bullets()函数
        fire_bullet(ai_settings, screen, ship, bullets)
        
    elif event.key == pygame.K_q:
        sys.exit() 
        
        
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, stats,  sb, play_button, ship, aliens, 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   
        elif event.type == pygame.KEYUP:
            check_keyup_events(event, ship)
            
        #添加响应play按钮的方法
        elif event.type == pygame.MOUSEBUTTONDOWN:
            mouse_x, mouse_y = pygame.mouse.get_pos()
            check_play_button(ai_settings, screen, stats, sb, play_button, ship, 
                        aliens, bullets, mouse_x, mouse_y)
            
def check_play_button(ai_settings, screen, stats, sb, play_button, ship, aliens, 
                bullets,  mouse_x, mouse_y):
    '''在玩家点击play时开始新游戏'''
    
    button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
    
    if button_clicked and not stats.game_active :
        #重置游戏（速度）设置
        ai_settings.initialize_dynamic_settings()
        
        #隐藏光标
        pygame.mouse.set_visible(False)
        
        #仅当玩家点击了play按钮且游戏当前处于非活动状态时，游戏才重新开始
        #重置统计信息
        stats.reset_stats()
        stats.game_active = True
        
        #重置记分牌图像
        sb.prep_score()
        sb.prep_high_score()
        sb.prep_level()
        sb.prep_ships()
        
        #清空外星人列表和子弹列表
        aliens.empty()
        bullets.empty()
        
        #创建一群新的外星人并让飞船居中
        create_fleet(ai_settings, screen, ship, aliens)
        ship.center_ship()
                
def update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets, play_button):
    '''更新屏幕上的图像，并切换到新屏幕'''
    #每次循环时都重绘屏幕
    #传入alien实例
    screen.fill(ai_settings.bg_color)
    
    #在飞船和外星人后面重绘所有子弹(外星人暂无)
    for bullet in bullets.sprites():
        bullet.draw_bullet()
        #用bullet遍历（列表中每个元素（由new_bullet组成））
    ship.blitme()
 
    aliens.draw(screen)
    sb.show_score()
    #在绘制play按钮前显示得分
    
    #如果游戏处于非活动状态，就绘制play按钮
    if not stats.game_active:
        play_button.draw_button()
    
    #让最近绘制的屏幕可见
    pygame.display.flip()
    
def update_bullets(ai_settings, screen, stats, sb, 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,stats, sb, ship, aliens, bullets)
   
def check_bullet_alien_collisions(ai_settings, screen,stats, sb, ship, aliens, bullets):
    '''响应子弹和外星人的碰撞'''
    #删除发生碰撞的子弹和外星人
    collisions = pygame.sprite.groupcollide(bullets, aliens,True, True)
    #创建一幅最新图像
    if collisions:
        for aliens in collisions.values():
            
            stats.score += ai_settings.alien_points * len(aliens)
            stats.score += ai_settings.alien_points
            sb.prep_score()
        #更新得分后检查是否突破原先最高得分的限制
        check_high_score(stats, sb)
    #这俩aliens没影响，for循环中的aliens变量因其遍历的是字典中的值（最少包含一个alien，不冲突）
    if len(aliens) == 0:     
        
        #删除现有所有子弹，加快游戏节奏，并创建一个新的外星人群
        #如果外星人被全部消灭，就提升一个等级
        
        bullets.empty()
        ai_settings.increase_speed()
        
        #提高等级
        stats.level += 1
        sb.prep_level()
        create_fleet(ai_settings, screen, ship, aliens)
        
        
def fire_bullet(ai_settings, screen, ship, bullets):
     #检查未消失的子弹数是否小于settings中允许的设置
     #如果未达到限制，就在发射一颗子弹
        if len(bullets) < ai_settings.bullets_allowed:
            
            #创建一颗子弹实例，并将其加入到编组bullets中
            new_bullet = Bullet(ai_settings, screen, ship)
            bullets.add(new_bullet)

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 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_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 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)

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 check_aliens_bottom(ai_settings,  screen, stats, sb, ship, aliens, bullets):
    '''检查是否有外星人到达了屏幕低端'''
    screen_rect = screen.get_rect()
    for alien in aliens.sprites():
        if alien.rect.bottom >= screen_rect.bottom:
            #像飞船被撞到一样处理
            ship_hit(ai_settings, screen, stats, sb,ship, aliens, bullets)
            break
            
    
def update_aliens(ai_settings,screen,stats, sb, ship, aliens,bullets):
    #传递sb,使其能够访问记分牌对象
    '''
    检查是否有外星人位于屏幕边缘，并更新整群外星人的位置
    '''
    #下移，调转方向
    check_fleet_edges(ai_settings,aliens)
    #左右移动
    aliens.update()
    #检查外星人和飞船之间的碰撞
    if pygame.sprite.spritecollideany(ship, aliens):
        
        ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets)
    #检查是否有外星人到达了屏幕低端
    check_aliens_bottom(ai_settings, screen, stats, sb, ship, aliens, bullets)

def ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets):
    '''响应被外星人撞到的飞船'''
    if stats.ships_left > 0:
            
        #将ship_left减一
        stats.ships_left -= 1
        
        #更新记分牌
        sb.prep_ships()
    
        #清空外星人列表和子弹列表’
        aliens.empty()
        bullets.empty()
        
        #创建一群新的外星人，并将飞船放到屏幕底部中央
        create_fleet(ai_settings, screen, ship, aliens)
        ship.center_ship()
        
        #暂停
        sleep(1)
    
    else :
        stats.game_active = False
        pygame.mouse.set_visible(True)
   
def check_high_score(stats, sb):
    '''检查是否诞生了最高得分'''
    if stats.score > stats.high_score:
        stats.high_score = stats.score
        sb.prep_high_score()

3.外星人的一些设置

#alienV2.py
#管理外星人的行为
#向右移动外星人
#检查外星人是否撞到屏幕边缘并修改update
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(r'C:\Users\totoro\Desktop\python_work\alien_invasion\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
        

4.子弹的设置

#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.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):
        '''向上移动子弹'''
        #更新表示子弹位置的小数值
        self.y -= self.speed_factor
        #更新表示子弹的rect的位置
        self.rect.y = self.y
        
    def draw_bullet(self):
        '''在屏幕上绘制子弹'''
        pygame.draw.rect(self.screen, self.color, self.rect)
            
    

5.play按钮的设置

#button.py
#创建带标签的实心矩形按钮

import pygame.font

class Button():
    def __init__(self, ai_settings, screen, msg):
        '''初始化按键的属性'''
        self.screen = screen
        self.screen_rect = screen.get_rect()
        
        #设置按键的尺寸和其他属性
        self.width, self.height = 200, 50
        self.button_color = (0, 255, 0)
        self.text_color = (255, 255, 255)
        self.font = pygame.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)
        
    def prep_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)
        

6.跟踪游戏统计信息

#game_statsV5.py
#跟踪游戏统计信息
#响应外星人与飞船的碰撞
#添加作为标志的属性game_active
#游戏开始处于非活动状态，play选择是否开始游戏
#实现计分系统，显示最高得分，当前等级和剩余飞船数
#跟踪并显示最高得分记录
#显示等级
class GameStats():
    '''跟踪游戏统计信息'''
    
    def __init__(self,ai_settings):
        '''初始化统计信息'''
        self.ai_settings = ai_settings
        self.reset_stats()
        #游戏刚启动时处于非活动状态
        self.game_active = False
        #在任何情况下都不应重置最高得分
        self.high_score = 0
        
        
    def reset_stats(self):
        '''初始化在游戏运行期间可能变化的统计信息'''
        self.ships_left = self.ai_settings.ship_limit
        #每次开始游戏时重置得分
        self.score = 0
        #每次开始新游戏时都重设等级
        self.level = 1
        
        

7.得分和等级的显示

#scoreboardV3.py
#在屏幕上显示得分
#将得分取整，设置得分的格式，添加千位分隔符，得分显示10的整数倍
#并修改方法__init__以显示最高得分
#在当前的分下方显示等级，编写方法
#创建一个可供显示的飞船编组,并在屏幕上显示飞船
import pygame.font
from pygame.sprite import Group
from shipV6 import Ship

class Scoreboard():
    ''' 显示得分信息的类 '''
    
    
    def __init__(self, ai_settings, screen, stats):
        ''' 初始化显示得分设计的属性 '''
        self.screen = screen
        self.screen_rect = screen.get_rect()
        self.ai_settings = ai_settings
        self.stats = 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_score(self):
        ''' 将得分转换为一副渲染的图像'''
        rounded_score = int(round(self.stats.score, -1))
        score_str = "{:,}".format(rounded_score)
        #score_str = "{:,}".format(rounded_score)

        self.score_image = self.font.render(score_str, True, self.text_color, 
                self.ai_settings.bg_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)
        self.screen.blit(self.high_score_image, self.high_score_rect)
        #在屏幕上显示等级
        self.screen.blit(self.level_image, self.level_rect)
        #绘制飞船
        self.ships.draw(self.screen)
    def prep_high_score (self):
        '''将最高得分转化为渲染的图像'''
        high_score = int(round(self.stats.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.screen_rect.top
    
    def prep_level(self):
        '''将等级转化为渲染的图像'''
        self.level_image = self.font.render(str(self.stats.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
        
        
    def prep_ships(self):
        '''显示还余下多少艘飞船'''
        self.ships = Group()
        for ship_number in range(self.stats.ships_left):
            ship = Ship(self.ai_settings, self.screen)
            ship.rect.x = 10 + ship_number * ship.rect.width
            ship.rect.y = 10
            self.ships.add(ship)
            #往编组中增加ship
            

8.游戏初始化设置

#settingsV9.py
#在settings中添加子弹设置
#限制同时出现在屏幕上的子弹数量
#向右移动外星人，添加外星人设置
#创建表示外星人移动方向的设置，向下，右移
#添加玩家一开始拥有的飞船数

#加快游戏节奏，将游戏划分为静态和动态两组
#初始化随游戏进行而变化的属性
#当玩家提高等级时，使用函数来提高飞船子弹和外星人的速度
#外星人的价值
#游戏节奏加快时提高点数
'''增加调整飞船的速度功能'''


class Settings():
    '''存储《外星人入侵》的所有设置的类'''
    def __init__(self):
    
        '''初始化游戏的静态设置'''
        #屏幕设置
        self.screen_width = 1200
        self.screen_height = 685
        self.bg_color = (230, 230, 230 )
        
        #飞船的设置

        self.ship_limit = 3
        
        #子弹设置
 
        self.bullet_width = 3
        self.bullet_height = 15
        self.bullet_color = 60, 60, 60
        #返回元组,深灰色子弹
        
        self.bullets_allowed = 4
        #将未消失的子弹数量限制为3个
        
        #外星人设置
        self.fleet_drop_speed = 10
        
        #以什么样的速度加快游戏节奏
        self.speedup_scale = 1.1
        #外星人点数的提高速度
        self.score_scale = 1.5
        
        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
        
        #fleet_direction为1表示向右移，为-1表示向左移
        self.fleet_direction = 1
        
        #计分
        self.alien_points = 50
        
    def increase_speed(self):
        '''提高速度设置和外星人点数'''
        self.ship_speed_factor *= self.speedup_scale
        self.bullet_speed_factor *= self.speedup_scale
        self.alien_speed_factor *= self.speedup_scale
        
        self.alien_points = int(self.alien_points * self.score_scale)
        #print(self.alien_points)
        
        

9.与飞船有关的相关功能

#shipV6.py
#加载飞船,
#允许持续移动，检测pygame.KEYUP事件
#在修改settingsV1.py的基础上(适应调整后的速度)
#限制飞船的活动范围
#添加让飞船在屏幕上居中函数
#让Ship继承Sprite，以便能够创建飞船编组，使用图像显示
'''结合使用KEYDOWN和KEYUP事件，及一个
名为moving_right的标志来实现持续移动，
作为飞船的属性，并添加update方法检查标
志moving_right的状态,允许飞船左右移动'''

import pygame 
from pygame.sprite import Sprite
class Ship(Sprite):
    #增加ai_settings参数，让飞船能够获取其速度设置
    def __init__(self, ai_settings, screen):
        '''初始化飞船并设置其初始位置'''
        super(Ship, self).__init__()
        self.screen = screen 
        self.ai_settings = ai_settings
        
        '''加载飞船图像并获取其外接矩形'''
        self.image = pygame.image.load(r'C:\Users\totoro\Desktop\python_work\alien_invasion\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
        
        #在飞船的属性center中存储小数值
        self.center = float(self.rect.centerx)
        
        #移动标志
        self.moving_right = False
        self.moving_left = False
    
    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
        
        #根据self.center更新rect对象
        self.rect.centerx = self.center
      
    def blitme(self):
        '''在指定位置绘制飞船'''
        self.screen.blit(self.image, self.rect)
    def center_ship(self):
        '''让飞船在屏幕上居中'''
        self.center = self.screen_rect.centerx
    

##10.最终实现效果