[Python]简单的外星人入侵游戏

alien_invasion.py:

 import sys

 import pygame

 from setting import Settings
 from ship import Ship
 import game_function as gf
 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.init()
     ai_setting = Settings()
     screen = pygame.display.set_mode((ai_setting.screen_width, ai_setting.screen_height))
     pygame.display.set_caption("Alien Invasion")

     # 创建一艘飞船、一个子弹编组和一个外星人编组
     ship = Ship(ai_setting, screen)
     bullets = Group()
     aliens = Group()

     # 创建外星人群
     gf.create_fleet(ai_setting, screen, ship, aliens)
     stats = GameStats(ai_setting)
     # 创建存储游戏统计信息的实例，并创建及分牌
     sb = ScoreBoard(ai_setting, screen, stats)
     # 创建Play按钮
     play_button = Button(ai_setting, screen, "Play")

     # 开始游戏的主循环
     while True:
         gf.check_events(ai_setting, screen, stats, sb, play_button, ship, aliens, bullets)
         if stats.game_active:
             ship.update()
             gf.update_bullets(ai_setting, screen, stats,  sb, ship, aliens, bullets)
             gf.update_aliens(ai_setting, stats, screen, sb, ship, aliens, bullets)

         gf.update_screen(ai_setting, screen, stats, sb, ship, aliens, bullets, play_button)

 run_game()

game_stats.py:

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

     def __init__(self, ai_setting):
         """初始化统计信息"""
         self.ai_setting = ai_setting
         self.reset_stats()
         self.game_active = False
         # 在任何情况下都不应该充值最高得分
         self.high_score = 0

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

scoreboard.py:

 import pygame.font
 from pygame.sprite import Group
 from ship import Ship

 class ScoreBoard():
     """现实得分信息的类"""

     def __init__(self, ai_setting, screen, stats):
         """初始化现实得分涉及的属性"""
         self.screen = screen
         self.screen_rect = screen.get_rect()
         self.ai_setting = ai_setting
         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.ship_left):
             ship = Ship(self.ai_setting, self.screen)
             ship.rect.x = 10 + ship_number * ship.rect.width
             ship.rect.y = 10
             self.ships.add(ship)

     def prep_score(self):
         """将得分转换为一幅渲染的图像"""
         rounded_score = int(round(self.stats.score, -1))
         score_str = "{:,}".format(rounded_score)
         self.score_image = self.font.render(score_str, True, self.text_color, self.ai_setting.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_setting.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

     def prep_level(self):
         """降等级转化为渲染的图像"""
         self.level_image = self.font.render(str(self.stats.level), True, self.text_color, self.ai_setting.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

button.py:

 import pygame.font

 class Button():
     def __init__(self, ai_setting, screen, msg):
         """初始化按钮的属性"""
         self.screen = screen
         self.screen_rect = screen.get_rect()

         # 设置按钮的尺寸和其他属性
         self.width = 200
         self.height = 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)

game_function.py:

 import sys

 import pygame
 from bullet import Bullet
 from alien import Alien
 from time import sleep

 def check_events(ai_setting, 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:
             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:
                 # 创建一颗子弹，并将其加入到编组bullets中
                 if len(bullets) < ai_setting.bullets_allowed:
                     new_bullet = Bullet(ai_setting, screen, ship)
                     bullets.add(new_bullet)
             elif event.key == pygame.K_q:
                 sys.exit()
         elif event.type == pygame.MOUSEBUTTONDOWN:
             mouse_x, mouse_y = pygame.mouse.get_pos()
             check_play_button(ai_setting, screen, stats, sb, play_button, ship, aliens, bullets, mouse_x, mouse_y)

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

 def check_play_button(ai_setting, 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_setting.initialize_dynamic_settings()

         # 隐藏光标
         pygame.mouse.set_visible(False)
         # 重置游戏信息
         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_setting, screen, ship, aliens)
         ship.center_ship()

 def update_screen(ai_setting, screen, stats, sb, ship,alien, bullets, play_button):
     """更新屏幕上的图像，并切换到新屏幕"""
     # 每次循环时都重绘屏幕
     screen.fill(ai_setting.bg_color)
     # 在飞船和外星人后面重绘所有子弹
     for bullet in bullets.sprites():
         bullet.draw_bullet()
     ship.blitme()
     alien.draw(screen)
     # 显示得分
     sb.show_score()

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

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

 def update_bullets(ai_setting, screen, stats,  sb, ship, aliens, bullets):
     """更新子弹位置，并删除已消失的子弹"""
     # 删除子弹的位置
     bullets.update()
     # 删除已消失的子弹
     for bullet in bullets.copy():
         if bullet.rect.bottom <= 0:
             bullets.remove(bullet)
     check_bullet_alien_colisions(ai_setting, screen, stats,  sb, ship, aliens, bullets)

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

 def check_bullet_alien_colisions(ai_setting, screen, stats,  sb, ship, aliens, bullets):
     """响应是否有子弹击中了外星人"""
     # 如果是这样，就删除相应的子弹和外星人
     collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)

     if collisions:
         for aliens in collisions.values():
             stats.score += ai_setting.alien_points * len(aliens)
             sb.prep_score()
         check_high_score(stats, sb)

     if len(aliens) == 0:
         # 删除现在的子弹,加快游戏节奏，并新建一群外星人
         bullets.empty()
         ai_setting.increase_speed()

         # 提高一个等级
         stats.level += 1
         sb.prep_level()

         create_fleet(ai_setting, screen, ship, aliens)

 def get_number_alien_x(ai_setting, alien_width):
     """计算每行可容纳多少个个外星人"""
     available_space_x = ai_setting.screen_width - 2 * alien_width
     number_aliens_x = int(available_space_x / (2 * alien_width))
     return number_aliens_x

 def create_alien(ai_setting, screen, aliens, alien_number, row_number):
     # 创建一个外星人并将其加入当前行
     alien = Alien(ai_setting, 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_setting, screen, ship, aliens):
     """创建外星人群"""
     # 创建一个外星人，并计算一行可容纳多少个外星人
     # 外星人间距为外星人宽度
     alien = Alien(ai_setting, screen)
     number_aliens_x = get_number_alien_x(ai_setting, alien.rect.width)
     number_rows = get_number_rows(ai_setting, ship.rect.height, alien.rect.height)

     # 创建第一行外星人
     for row_number in range(number_rows):
         for alien_number in range(number_aliens_x):
             create_alien(ai_setting, screen, aliens, alien_number, row_number)

 def get_number_rows(ai_setting, ship_height, alien_height):
     """计算屏幕可容纳多少行外星人"""
     available_space_y = (ai_setting.screen_height - (3 * alien_height) - ship_height)
     number_rows = int(available_space_y / (2 * alien_height))
     return number_rows

 def check_fleet_edges(ai_setting, aliens):
     """有外星人到达边缘时采取相应的措施"""
     for alien in aliens.sprites():
         if alien.check_edges():
             change_fleet_direction(ai_setting, aliens)
             break

 def change_fleet_direction(ai_setting, aliens):
     """将整群外星人下移"""
     for alien in aliens.sprites():
         alien.rect.y += ai_setting.fleet_drop_speed
     ai_setting.fleet_direction *= -1

 def update_aliens(ai_setting, stats, screen, sb, ship, aliens, bullets):
     check_fleet_edges(ai_setting, aliens)
     aliens.update()

     # 检测外星人和飞船之间的碰撞
     if pygame.sprite.spritecollideany(ship, aliens):
         ship_hit(ai_setting, stats, screen, sb, ship, aliens, bullets)
     # 检查是否有外星人大大屏幕底端
     check_aliens_bottom(ai_setting, stats, screen, sb, ship, aliens, bullets)

 def ship_hit(ai_setting, stats, screen, sb, ship, aliens, bullets):
     """响应被外星人撞到的飞船"""
     if stats.ship_left > 0:
         # 将ship_left减1
         stats.ship_left -= 1

         # 更新记分牌
         sb.prep_ships()

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

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

         # 暂停
         sleep(0.5)
     else:
         stats.game_active = False

 def check_aliens_bottom(ai_setting, stats, screen, sb, 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, sb, ship, aliens, bullets)
             break

alien.py:

 import pygame
 from pygame.sprite import Sprite

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

     def __init__(self, ai_setting, screen):
         """初始化外星人并设置其起始位置"""
         super(Alien, self).__init__()
         self.screen = screen
         self.ai_setting = ai_setting

         # 加载外星人图像，并设计其rect属性
         self.image = pygame.image.load('images/alien.bmp')
         self.rect = self.image.get_rect()

         # 每个外星人最初都在屏幕左上角附近
         self.rect.x = self.rect.width
         self.rect.y = self.rect.height

         # 存储外星人的准确位置
         self.x = float(self.rect.x)

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

     def check_edges(self):
         """如果外星人位于屏幕边缘，就返回True"""
         screen_rect = self.screen.get_rect()
         if self.rect.right >= screen_rect.right:
             return True
         elif self.rect.left <= 0:
             return True

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

setting.py:

 class Settings():
     """存储《外星人入侵》的所有设置的类"""

     def __init__(self):
         """初始化游戏的设置"""
         # 屏幕设置
         self.screen_width = 900
         self.screen_height = 600
         self.bg_color = (230, 230, 230)
         # 飞船的设置
         self.ship_speed_factor = 1.5
         # 子弹设置
         self.bullet_speed_factor = 3
         self.bullet_width = 3
         self.bullet_height = 15
         self.bullet_color = 60, 60, 60
         self.bullets_allowed = 3
         self.alien_speed_factor = 1
         self.fleet_drop_speed = 10
         self.fleet_direction = 1
         self.ship_limit = 3
         # 以什么样的速度加快游戏的节奏
         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.bullet_speed_factor *= self.speedup_scale
         self.alien_points = int(self.alien_points * self.score_scale)

bullet.py:

 import pygame
 from pygame.sprite import Sprite

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

         # 在(0,0)处创建一个表示子弹的矩形，在设置正确的位置
         self.rect = pygame.Rect(0, 0, ai_setting.bullet_width, ai_setting.bullet_height)
         self.rect.centerx = ship.rect.centerx
         self.rect.top = ship.rect.top

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

         self.color = ai_setting.bullet_color
         self.speed_factor = ai_setting.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)

ship.py:

 import  pygame
 from pygame.sprite import Sprite

 class Ship(Sprite):

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

         """加载飞船图像并获取其外接矩阵"""
         self.image = pygame.image.load('images/ship.bmp')
         self.rect = self.image.get_rect()
         self.screen_rect = screen.get_rect()

         # 将每艘新飞船放在屏幕底部中央
         self.rect.centerx = self.screen_rect.centerx
         self.rect.bottom = self.screen_rect.bottom

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

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

     def update(self):
         """根据移动标志调增飞船的位置"""
         if self.moving_right and self.rect.right < self.screen_rect.right:
             self.center += self.ai_setting.ship_speed_factor
         if self.moving_left and self.rect.left > 0:
             self.center -= self.ai_setting.ship_speed_factor

         """根据self.center调整飞船的位置"""
         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

图片: