模仿学习小游戏外星人入侵-Python学习，体会“函数”编程

游戏类如下：

 # !/usr/bin/python
 # -*- coding:utf-8 -*-
 """
 Author   :ZFH
 File     :alien.py
 Software :PyCharm
 Datetime :2019-01-14 17:31
 Version  :v1.0
 Funciton :
 """
 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.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 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.rect.x = self.x
         """向右或者向左移动外星人"""
         self.x += (self.ai_settings.alien_speed_factor * self.ai_settings.fleet_direction)
         self.rect.x = self.x

 # !/usr/bin/python
 # -*- coding:utf-8 -*-
 """
 Author   :ZFH
 File     :alien_invasion.py
 Software :PyCharm
 Datetime :2019-01-11 15:10
 Version  :v1.0
 Funciton :
 """

 import sys,pygame
 from settings import Settings
 from ship import Ship
 import game_functions
 from pygame.sprite import Group
 from alien import Alien
 from game_stats import GameStats
 from button import  Button
 from scoreboard import ScoreBoard

 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('zfh')

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

     # 创建一个用于存储游戏统计信息的实例，并创建记分牌
     stats = GameStats(ai_settings)
     scoreboard = ScoreBoard(ai_settings, screen, stats)

     # 创建一艘飞船
     ship = Ship(ai_settings, screen)

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

     # 创建一个用于存储子弹的编组
     bullets = Group()

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

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

     # 开始游戏的主循环

     while True:
         # 监视键盘和鼠标事件
         # for event in pygame.event.get():
         #     if event.type == pygame.QUIT:
         #         sys.exit()
         # check_functions.check_events()
         # # 每次循环时都重绘制屏幕
         # screen.fill(ai_settings.bg_color)
         # ship.blitme()
         #
         # # 让最近绘画的屏幕可见
         # pygame.display.flip()

         game_functions.check_events(ai_settings, screen, stats, scoreboard, play_button, ship, aliens, bullets)

         if stats.game_active:

             ship.update()

             ## 更新子弹的位置
             # bullets.update()
             #
             # # 删除已消失的子弹
             # for bullet in  bullets.copy():
             #     if bullet.rect.bottom <= 0:
             #         bullets.remove(bullet)
             game_functions.update_bullets(ai_settings, screen, stats, scoreboard, ship, aliens, bullets)

             game_functions.update_aliens(ai_settings, stats, screen, scoreboard, ship, aliens, bullets)

         game_functions.update_screen(ai_settings, screen, stats,scoreboard, ship, aliens, bullets, play_button)

         # game_functions.update_bullets(bullets)

 run_game()

 # !/usr/bin/python
 # -*- coding:utf-8 -*-
 """
 Author   :ZFH
 File     :bullet.py
 Software :PyCharm
 Datetime :2019-01-14 15:35
 Version  :v1.0
 Funciton :
 """
 import pygame
 from pygame.sprite import Sprite

 class Bullet(Sprite):
     """一个对飞船发射子弹进行管理的类"""

     def __init__(self,ai_settings, screen, ship, *args, **kwargs):
         """在飞船所处位置创建一个子弹对象"""
         super(Bullet, self).__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)

 # !/usr/bin/python
 # -*- coding:utf-8 -*-
 """
 Author   :ZFH
 File     :button.py
 Software :PyCharm
 Datetime :2019-01-24 10:24
 Version  :v1.0
 Funciton :
 """
 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)

 # !/usr/bin/python
 # -*- coding:utf-8 -*-
 """
 Author   :ZFH
 File     :game_functions.py
 Software :PyCharm
 Datetime :2019-01-11 16:46
 Version  :v1.0
 Funciton :
 """
 import sys,pygame
 from bullet import Bullet
 from alien import  Alien
 from time import sleep

 def check_events(ai_settings, screen, stats, scoreboard, paly_button, ship, aliens, bullets, *args, **kwargs):

     """
         响应按键和鼠标事件
     """
     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.rect.centerx += 1
             #     ship.moving_right = True
             # elif event.key == pygame.K_LEFT:
             #     # 向左移动飞船
             #     ship.moving_left = True
             check_keydown_events(event, ai_settings, screen, ship, bullets)

         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
             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, scoreboard, paly_button,  ship, aliens, bullets, mouse_x, mouse_y)

 def check_keydown_events(event, ai_settings, screen, ship, bullets, *args, **kwargs):

     """响应按键"""
     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_UP:
         ship.moving_up = True
     elif event.key == pygame.K_DOWN:
         ship.moving_down = True
     elif event.key == pygame.K_SPACE:
         fire_bullet(ai_settings, screen, ship, bullets)
     elif event.key == pygame.K_q:
         sys.exit()

 def fire_bullet(ai_settings, screen, ship, bullets, *args, **kwargs):
     """如果没有达到限制，就发射一颗子弹"""
     # 创建一颗子弹，并将其加入到编组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, *args, **kwargs):
     """响应松开"""
     if event.key == pygame.K_RIGHT:
         ship.moving_right = False
     elif event.key == pygame.K_LEFT:
         ship.moving_left = False
     elif event.key == pygame.K_UP:
         ship.moving_up = False
     elif event.key == pygame.K_DOWN:
         ship.moving_down = False

 def update_screen(ai_settings, screen, stats, scoreboard, ship, aliens, bullets, play_button, *args, **kwargs):
     """更新屏幕上的图像，并切换到新屏幕"""
     # 每次循环时都重绘屏幕
     screen.fill(ai_settings.bg_color)
     for bullet in  bullets.sprites():
         bullet.draw_bullet()
     ship.blitme()

     # 让外星人出现在屏幕上
     # alien.blitme()

     #绘制外星人编组
     aliens.draw(screen)

     # 显示得分
     scoreboard.show_score()

     # 如果游戏处于非活动状态，就绘制Play按钮
     if not stats.game_active:
         play_button.draw_button()

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

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

 def check_bullet_alien_collisions(ai_settings, screen, stats, scoreboard, 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)
             scoreboard.prep_score()
         check_high_score(stats, scoreboard)

     if len(aliens) == 0:
         # 删除现有的子弹,"加快游戏节奏"，并新建一群外星人,游戏就提高一个等级
         bullets.empty()
         ai_settings.increase_speed()

         # 提高等级
         stats.level += 1
         scoreboard.prep_level()

         create_fleet(ai_settings, screen, ship, aliens)

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

 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, 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)
     # 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))
     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):
         #     # 创建一个外星人并将其加入当前行
         #     alien = Alien(ai_settings, screen)
         #     alien.x = alien_width + 2 * alien_width * alien_number
         #     alien.rect.x = alien.x
         #     aliens.add(alien)
             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 ship_hit(ai_settings, stats, screen, scoreboard, ship, aliens, bullets):
     """响应外星人撞到飞船"""
     if stats.ships_left > 0:
         # 将ships_left减1
         stats.ships_left -= 1

         # 更新记分牌
         scoreboard.prep_ships()

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

         # 创建一群新的外星人，并将飞船放到屏幕低端中央
         create_fleet(ai_settings, screen, ship, aliens)

         ship.center_ship()

         # 暂停
         sleep(0.5)
     else:
         stats.game_active = False
         print("Game Over !!!")
         pygame.mouse.set_visible(True)

 def check_aliens_bottom(ai_setting, stats, screen, scoreboard, ship, aliens, bullets):
     """检查是否有外星人到达了屏幕底端"""
     screen_rect = screen.get_rect()
     for alien in aliens.sprites():
         if alien.rect.bottom >= screen_rect.bottom:
             # 像飞船被撞到一样处理
             ship_hit(ai_setting, stats, screen, scoreboard, ship, aliens, bullets)
             break

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

     aliens.update()

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

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

 def check_play_button(ai_settings, screen, stats, scoreboard, paly_button,  ship, aliens, bullets, mouse_x, mouse_y):
     """在玩家点击play按钮时开始新游戏"""
     button_clicked = paly_button.rect.collidepoint(mouse_x, mouse_y)

     # if paly_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)
         # 重置游戏统计信息
         stats.reset_stats()
         stats.game_active = True

         # 重置记分牌图像
         scoreboard.prep_score()
         scoreboard.prep_high_score()
         scoreboard.prep_level()
         scoreboard.prep_ships()

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

         # 创建一群新的外星人，并将飞船放到屏幕低端中央
         create_fleet(ai_settings, screen, ship, aliens)

         ship.center_ship()

 # !/usr/bin/python
 # -*- coding:utf-8 -*-
 """
 Author   :ZFH
 File     :game_stats.py
 Software :PyCharm
 Datetime :2019-01-24 9:29
 Version  :v1.0
 Funciton :
 """

 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

 # !/usr/bin/python
 # -*- coding:utf-8 -*-
 """
 Author   :ZFH
 File     :scoreboard.py
 Software :PyCharm
 Datetime :2019-01-24 11:24
 Version  :v1.0
 Funciton :
 """
 import pygame.font
 from pygame.sprite import Group
 from ship 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_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_internal(ship)

     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_score(self):
         """将得分转换为一副渲染的图像"""
         rounded_score = int(round(self.stats.score, -1))
         # score_str = str(self.stats.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 prep_high_score(self):
         """将最高得分转换为渲染图像"""
         high_score = int(round(self.stats.high_score, -1))
         high_score_str = "{:,}".format(high_score)
         self.prep_high_image = self.font.render(high_score_str, True, self.text_color, self.ai_settings.bg_color)

         # 将最高得分放在屏幕顶部中央
         self.high_score_rect = self.prep_high_image.get_rect()
         self.high_score_rect.centerx = self.screen_rect.centerx
         self.high_score_rect.top = self.score_rect.top

     def show_score(self):
         """在屏幕上显示得分"""
         self.screen.blit(self.score_image, self.score_rect)
         # 在屏幕上显示最高得分
         self.screen.blit(self.prep_high_image, self.high_score_rect)
         # 在屏幕上方显示游戏等级
         self.screen.blit(self.level_image, self.level_rect)

         # 绘制飞船
         self.ships.draw(self.screen)

 # !/usr/bin/python
 # -*- coding:utf-8 -*-
 """
 Author   :ZFH
 File     :settings.py
 Software :PyCharm
 Datetime :2019-01-11 15:23
 Version  :v1.0
 Funciton :
 """
 class Settings():
     """
         存储《外星人入侵》的所有设置的类
     """
     def __init__(self):
         """初始化游戏静态设置"""
         """
         初始化游戏设置
         """
         # 屏幕设置
         self.screen_width = 1200
         self.screen_height = 800
         self.bg_color = (255, 255, 255)

         # 设置飞机的速度
         self.ship_speed_factor = 3
         self.ship_limit = 3

         # 子弹射击
         self.bullet_speed_factor = 1
         self.bullet_width = 5
         self.bullet_height = 5
         self.bullet_color = (236, 28, 36)
         self.bullets_allowed = 10

         # 外星人设置
         self.alien_speed_factor = 1
         self.fleet_drop_speed = 2
         # 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_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)

 # !/usr/bin/python
 # -*- coding:utf-8 -*-
 """
 Author   :ZFH
 File     :ship.py
 Software :PyCharm
 Datetime :2019-01-11 15:42
 Version  :v1.0
 Funciton :
 """
 import pygame

 class Ship():

     def __init__(self,ai_settings, screen, *args, **kwargs):
         """初始化飞船并设置其初始位置"""
         super(Ship, self).__init__()

         self.screen = screen
         self.ai_settings = ai_settings
         # 加载飞船图像并获取其外接矩形
         self.image = pygame.image.load('images/ship1.png')
         self.rect = self.image.get_rect()
         self.screen_rect = screen.get_rect()

         # 将每艘飞船放在屏幕底部中央
         self.rect.centerx = self.screen_rect.centerx     #将飞船中心的x坐标设置为表示屏幕的矩形的属性centerx
         self.rect.bottom = self.screen_rect.bottom       #注意屏幕边缘的表示：top，bottom，left，right
                                                          #将每艘飞船放置在屏幕底端中央位置，在pygame中，原点（0，0）位于屏幕左上角

         # 在飞船的属性centerx中存储小数值
         self.center = float(self.rect.centerx)
         self.bottom = float(self.rect.bottom)

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

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

     def update(self):
         """
             根据移动标志调整飞船位置
         """
         # 更新飞船的center值，而不是rect,self.rect.right < self.screen_rect.right限制飞船的右侧位置。
         if self.moving_right and self.rect.right < self.screen_rect.right:
             # self.rect.centerx += 1
             self.center += self.ai_settings.ship_speed_factor
         # self.rect.left > 0 限制飞船右侧得位置
         if self.moving_left and self.rect.left >= 0:
             # self.rect.centerx -= 1
             self.center -= self.ai_settings.ship_speed_factor

         if self.moving_up and self.rect.top >= 0 :
             self.bottom -= self.ai_settings.ship_speed_factor

         if self.moving_down and self.rect.bottom < self.screen_rect.bottom:
             self.bottom += self.ai_settings.ship_speed_factor

         self.rect.centerx = self.center
         self.rect.bottom = self.bottom

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

效果如下，飞船太难看了.......