devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

外星人入侵（python）_外星人入侵(python)-csdn博客 ship, aliens, m

作者：weixin_40725706 | 2024-02-21 07:33:19

赞

踩

外星人入侵(python)-csdn博客 ship, aliens, m

前言

代码来源《python编程从入门到实践》Eric Matthes 署 袁国忠 译

使用软件：PyCharm Community Editor 2022

目的：记录一下按照书上敲的代码

alien_invasion.py

游戏的一些初始化设置，调用已经封装好的函数方法，一个函数的调用实现一个游戏的部分。

  1. import pygame
  2. from settings import Settings
  3. from ship import Ship
  4. import game_functions as gf
  5. from pygame.sprite import Group
  6. from game_stats import GameStats
  7. from button import Button
  8. from scoreboard import Scoreboard
  9.  
  10.  
  11. def run_game():
  12.     # 初始化游戏并创建一个屏幕对象
  13.     pygame.init()
  14.     ai_settigns = Settings()
  15.     # 里面是一个元组
  16.     screen = pygame.display.set_mode((ai_settigns.screen_width, ai_settigns.screen_height))
  17.     # 窗口尺寸，宽高
  18.     # screen=pygame.display.set_mode((1200,800))
  19.     # 窗口标题
  20.     pygame.display.set_caption("Alien Invasion")
  21.     # 创建Play按钮
  22.     play_button = Button(ai_settigns, screen, "Play")
  23.     # 创建一个用于存储游戏统计信息的实例
  24.     stats = GameStats(ai_settigns)
  25.     # 创建储存游戏统计信息的实例，并创建记分牌
  26.     sb = Scoreboard(ai_settigns, screen, stats)
  27.  
  28.     # 设置背景色
  29.     # bg_color=(230,230,230)
  30.     # 创建一艘飞船、一个子弹编组和一个外星人编组
  31.     ship = Ship(ai_settigns, screen)
  32.     # 创建一个用于存储子弹的编组
  33.     bullets = Group()
  34.     # 创建一个外星人
  35.     # alien=Alien(ai_settigns,screen)
  36.     aliens = Group()
  37.     # 创建外星人群
  38.     gf.create_fleet(ai_settigns, screen, ship, aliens)
  39.  
  40.     # 开始游戏的主循环
  41.     while True:
  42.         gf.check_events(ai_settigns, screen, stats, sb, play_button, ship, aliens, bullets)
  43.         if stats.game_active:
  44.             ship.update()
  45.             gf.update_bullets(ai_settigns, screen, stats, sb, ship, aliens, bullets)
  46.             gf.update_aliens(ai_settigns, screen, stats, sb, ship, aliens, bullets)
  47.         # print(len(bullets))
  48.  
  49.         gf.update_screen(ai_settigns, screen, stats, sb, ship, aliens, bullets, play_button)
  50.         # 监视键盘和鼠标事件
  51.         # for event in pygame.event.get():
  52.         #     if event.type==pygame.QUIT:
  53.         #         sys.exit()
  54.         # 每次循环都重绘屏幕
  55.         # screen.fill(bg_color)
  56.         # screen.fill(ai_settigns.gb_color)
  57.         # ship.blitme()
  58.         # 让最近绘制的屏幕可见
  59.         # pygame.display.flip()
  60.  
  61.  
  62. run_game()

game_functions.py

 游戏主体，具体功能的实现被封装在里面，按下按键、松开按键的响应，界面的更新、子弹的发射、外星人和飞船之间碰撞的检查等等。

  1. import sys
  2. import pygame
  3. from bullet import Bullet
  4. from alien import Alien
  5. from time import sleep
  6.  
  7.  
  8. # 响应按键
  9. def check_keydown_events(event, ai_settings, screen, ship, bullets):
  10.     if event.key == pygame.K_RIGHT:
  11.         ship.moving_right = True
  12.     elif event.key == pygame.K_LEFT:
  13.         ship.moving_left = True
  14.     elif event.key == pygame.K_SPACE:
  15.         fire_bullet(ai_settings, screen, ship, bullets)
  16.     # 按下键盘上的q键同样关闭游戏界面(需要是英文状态下)
  17.     elif event.key == pygame.K_q:
  18.         sys.exit()
  19.  
  20.  
  21. # 响应松开
  22. def check_keyup_events(event, ship):
  23.     if event.key == pygame.K_RIGHT:
  24.         ship.moving_right = False
  25.     elif event.key == pygame.K_LEFT:
  26.         ship.moving_left = False
  27.  
  28.  
  29. # 响应按键和鼠标事件
  30. def check_events(ai_settings, screen, stats, sb, play_button, ship, aliens, bullets):
  31.     for event in pygame.event.get():
  32.         if event.type == pygame.QUIT:
  33.             sys.exit()
  34.  
  35.         elif event.type == pygame.KEYDOWN:
  36.             # if event.key == pygame.K_RIGHT:
  37.             #     ship.moving_right = True
  38.             # elif event.key == pygame.K_LEFT:
  39.             #     ship.moving_left = True
  40.             check_keydown_events(event, ai_settings, screen, ship, bullets)
  41.         elif event.type == pygame.KEYUP:
  42.             # if event.key == pygame.K_RIGHT:
  43.             #     ship.moving_right = False
  44.             # elif event.key == pygame.K_LEFT:
  45.             #     ship.moving_left = False
  46.             check_keyup_events(event, ship)
  47.         elif event.type == pygame.MOUSEBUTTONDOWN:
  48.             mouse_x, mouse_y = pygame.mouse.get_pos()
  49.             check_play_button(ai_settings, screen, stats, sb, play_button, ship, aliens, bullets, mouse_x, mouse_y)
  50.  
  51.  
  52. # 更新屏幕上的图像，并切换到新屏幕
  53. def update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets, play_button):
  54.     # 每次循环时都重绘屏幕
  55.     screen.fill(ai_settings.bg_color)
  56.     # 在飞船和外星人后面重绘所有子弹
  57.     for bullet in bullets.sprites():
  58.         bullet.draw_bullet()
  59.     ship.blitme()
  60.     aliens.draw(screen)
  61.     # 显示得分
  62.     sb.show_score()
  63.     # 如果游戏处于非活动状态，就绘制Play按钮
  64.     if not stats.game_active:
  65.         play_button.draw_button()
  66.     # 让最近绘制的屏幕可见
  67.     pygame.display.flip()
  68.  
  69.  
  70. # 更新子弹的位置，并删除已经消失的子弹
  71. def update_bullets(ai_settings, screen, stats, sb, ship, aliens, bullets):
  72.     # 更新子弹的位置
  73.     bullets.update()
  74.  
  75.     # 删除已经消失的子弹
  76.     for bullet in bullets.copy():
  77.         if bullet.rect.bottom <= 0:
  78.             bullets.remove(bullet)
  79.  
  80.     # 检查是否有子弹击中了外星人
  81.     # 如果是这样，就删除相应的子弹和外星人
  82.     check_bullet_alien_collision(ai_settings, screen, stats, sb, ship, aliens, bullets)
  83.  
  84.  
  85. # 响应子弹和外星人的碰撞
  86. def check_bullet_alien_collision(ai_settings, screen, stats, sb, ship, aliens, bullets):
  87.     # 删除发生碰撞的子弹和外星人
  88.     collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)
  89.     if collisions:
  90.         for aliens in collisions.values():
  91.             stats.score += ai_settings.alien_points
  92.             sb.prep_score()
  93.         check_high_score(stats, sb)
  94.  
  95.     if len(aliens) == 0:
  96.         # 删除现有的子弹并新建一群外星人(如果整群外星人都被消灭，就提高一个等级)
  97.         bullets.empty()
  98.         ai_settings.increase_speed()
  99.         # 提高等级
  100.         stats.level += 1
  101.         sb.prep_level()
  102.  
  103.         create_fleet(ai_settings, screen, ship, aliens)
  104.  
  105.  
  106. # 如果还没有到达限制，就发射一颗子弹
  107. def fire_bullet(ai_settings, screen, ship, bullets):
  108.     # 创建一颗子弹,并将其加入到编组bullets中
  109.     if len(bullets) < ai_settings.bullets_allowed:
  110.         new_bullet = Bullet(ai_settings, screen, ship)
  111.         bullets.add(new_bullet)
  112.  
  113.  
  114. # 创建一个外星人群
  115. def create_fleet(ai_settings, screen, ship, aliens):
  116.     # 创建一个外星人，并计算每行可容纳多少个外星人
  117.     alien = Alien(ai_settings, screen)
  118.     number_aliens_x = get_number_aliens_x(ai_settings, alien.rect.width)
  119.     number_rows = get_number_rows(ai_settings, ship.rect.height, alien.rect.height)
  120.  
  121.     # 创建外星人群
  122.     for row_number in range(number_rows):
  123.         for alien_number in range(number_aliens_x):
  124.             # 创建一个外星人并将其加入当前行
  125.             create_alien(ai_settings, screen, aliens, alien_number, row_number)
  126.  
  127.  
  128. # 计算每行可容纳多少个外星人
  129. def get_number_aliens_x(ai_settings, alien_width):
  130.     available_space_x = ai_settings.screen_width - 2 * alien_width
  131.     number_aliens_x = int(available_space_x / (2 * alien_width))
  132.     return number_aliens_x
  133.  
  134.  
  135. # 创建一个外星人并将其放在当前行
  136. def create_alien(ai_settings, screen, aliens, alien_number, row_number):
  137.     # 外星人间距为外星人的宽度
  138.     alien = Alien(ai_settings, screen)
  139.     alien_width = alien.rect.width
  140.     alien.x = alien_width + 2 * alien_width * alien_number
  141.     alien.rect.x = alien.x
  142.     alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
  143.     aliens.add(alien)
  144.  
  145.  
  146. # 计算屏幕可容纳多少行外星人
  147. def get_number_rows(ai_settings, ship_height, alien_height):
  148.     available_space_y = (ai_settings.screen_height - (3 * alien_height) - ship_height)
  149.     number_rows = int(available_space_y / (2 * alien_height))
  150.     return number_rows
  151.  
  152.  
  153. # 检查是否有外星人位于屏幕边缘，更新外星人群中所有外星人的位置
  154. def update_aliens(ai_settings, screen, stats, sb, ship, aliens, bullets):
  155.     check_fleet_edges(ai_settings, aliens)
  156.     aliens.update()
  157.  
  158.     # 检测外星人和飞船之间的碰撞
  159.     if pygame.sprite.spritecollideany(ship, aliens):
  160.         # print("Ship hit!!!")
  161.         ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets)
  162.  
  163.     # 检查是否有外星人到达屏幕底端
  164.     check_aliens_bottom(ai_settings, screen, stats, sb, ship, aliens, bullets)
  165.  
  166.  
  167. # 有外星人到达边缘采取相应的措施
  168. def check_fleet_edges(ai_settings, aliens):
  169.     for alien in aliens.sprites():
  170.         if alien.check_edges():
  171.             change_fleet_direction(ai_settings, aliens)
  172.             break
  173.  
  174.  
  175. # 将整群外星人下移，并改变他们的方向
  176. def change_fleet_direction(ai_settings, aliens):
  177.     for alien in aliens.sprites():
  178.         alien.rect.y += ai_settings.fleet_drop_speed
  179.     ai_settings.fleet_direction *= -1
  180.  
  181.  
  182. # 响应被外星人撞到的飞船
  183. def ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets):
  184.     if stats.ships_left > 0:
  185.         # 将ships_letf减1
  186.         stats.ships_left -= 1
  187.  
  188.         # 更新记分牌
  189.         sb.prep_ships()
  190.  
  191.         # 清空外星人列表和子弹列表
  192.         aliens.empty()
  193.         bullets.empty()
  194.  
  195.         # 创建一群新的外星人，并将飞船放到屏幕底端中央
  196.         create_fleet(ai_settings, screen, ship, aliens)
  197.         ship.center_ship()
  198.  
  199.         # 暂停
  200.         sleep(0.5)
  201.     else:
  202.         stats.game_active = False
  203.         pygame.mouse.set_visible(True)
  204.  
  205.  
  206. # 检查是否有外星人到达了屏幕底端
  207. def check_aliens_bottom(ai_settings, screen, stats, sb, ship, aliens, bullets):
  208.     screen_rect = screen.get_rect()
  209.     for alien in aliens.sprites():
  210.         if alien.rect.bottom >= screen_rect.bottom:
  211.             # 向飞船被撞到一样进行处理
  212.             ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets)
  213.             break
  214.  
  215.  
  216. # 在玩家单机Play按钮时开始新游戏
  217. def check_play_button(ai_settings, screen, stats, sb, play_button, ship, aliens, bullets, mouse_x, mouse_y):
  218.     button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
  219.     if button_clicked and not stats.game_active:
  220.         # 重置游戏设置
  221.         ai_settings.initialize_dynamic_settings()
  222.         # 隐藏光标
  223.         pygame.mouse.set_visible(False)
  224.         # 重置游戏统计信息
  225.         stats.reset_stats()
  226.         stats.game_active = True
  227.  
  228.         # 重置记分牌图像
  229.         sb.prep_score()
  230.         sb.prep_high_score()
  231.         sb.prep_level()
  232.         sb.prep_ships()
  233.  
  234.         # 清空外星人列表和子弹列表
  235.         aliens.empty()
  236.         bullets.empty()
  237.  
  238.         # 创建一群新的外星人，并让飞船居中
  239.         create_fleet(ai_settings, screen, ship, aliens)
  240.         ship.center_ship()
  241.  
  242.  
  243. # 检查是否诞生了新的最高部分
  244. def check_high_score(stats, sb):
  245.     if stats.score > stats.high_score:
  246.         stats.high_score = stats.score
  247.         sb.prep_high_score()

settings.py

游戏的一些初始化数据的储存，子弹的速度，大小，屏幕的大小等等。

  1. # 储存《外星人入侵》所设置的类
  2. class Settings():
  3.     # 初始化游戏的静态属性
  4.     def __init__(self):
  5.         # 屏幕设置
  6.         self.screen_width = 1200
  7.         self.screen_height = 800
  8.         self.bg_color = (230, 230, 230)
  9.  
  10.         # 飞船设置
  11.         # 位置
  12.         self.ship_speed_factor = 1.5
  13.         self.ship_limit = 3
  14.  
  15.         # 子弹设置(宽高，颜色)
  16.         self.bullet_speed_factor = 1  # 速度
  17.         self.bullet_width = 3  # 宽度
  18.         self.bullet_height = 15  # 高度
  19.         self.bullet_color = 60, 60, 60  # 颜色
  20.         self.bullets_allowed = 3
  21.  
  22.         # 外星人设置
  23.         self.alien_speed_factor = 1
  24.         self.fleet_drop_speed = 10
  25.         # fleet_direction为1表示向右移，为-1表示向左移
  26.         self.fleet_direction = 1
  27.  
  28.         # 以什么样的速度加快游戏节奏
  29.         self.speedup_scale = 1.1
  30.         # 外星人点数的提高速度
  31.         self.score_scale = 1.5
  32.         self.initialize_dynamic_settings()
  33.  
  34.         # 记分
  35.         self.alien_points = 50
  36.  
  37.     # 初始化随游戏进行而变化的设置
  38.     def initialize_dynamic_settings(self):
  39.         self.ship_speed_factor = 1.5
  40.         self.bullet_speed_factor = 3
  41.         self.alien_speed_factor = 1
  42.  
  43.         # fleet_direction为1表示向右；为-1表示向左
  44.         self.fleet_direction = 1
  45.  
  46.     # 提高速度和外星人点数设置
  47.     def increase_speed(self):
  48.         self.ship_speed_factor *= self.speedup_scale
  49.         self.bullet_speed_factor *= self.speedup_scale
  50.         self.alien_speed_factor *= self.speedup_scale
  51.  
  52.         self.alien_points = int(self.alien_points * self.score_scale)
  53.         print(self.alien_points)

ship.py

 飞船的初始化信息（在屏幕上面显示的位置）和移动。

  1. import pygame
  2. from pygame.sprite import Sprite
  3.  
  4. class Ship(Sprite):
  5.     # 初始化飞船并设置其初始位置
  6.     def __init__(self, ai_settings, screen):
  7.         super(Ship, self).__init__()
  8.         self.screen = screen
  9.         self.ai_settings = ai_settings
  10.         # 加载飞船图像并获取外接矩形
  11.         self.image = pygame.image.load('images/ship.png')
  12.         self.rect = self.image.get_rect()
  13.         self.screen_rect = screen.get_rect()
  14.         # 将每艘新飞船放在屏幕底部中央
  15.         self.rect.centerx = self.screen_rect.centerx
  16.         self.rect.bottom = self.screen_rect.bottom
  17.         # 在飞船的属性center中存储小数值
  18.         self.center = float(self.rect.centerx)
  19.  
  20.         # 移动标志
  21.         self.moving_right = False
  22.         self.moving_left = False
  23.  
  24.     # 根据移动标志调整飞船的位置
  25.     def update(self):
  26.         # 更新飞船的center值，而不是rect
  27.         # if self.moving_right:
  28.         # 增加不能越界的条件
  29.         if self.moving_right and self.rect.right < self.screen_rect.right:
  30.             # self.rect.centerx += 1
  31.             self.center += self.ai_settings.ship_speed_factor
  32.         # elif self.moving_left:
  33.         if self.moving_left and self.rect.left > 0:
  34.             # self.rect.centerx -= 1
  35.             self.center -= self.ai_settings.ship_speed_factor
  36.  
  37.         # 根据self.center更新rect对象
  38.         self.rect.centerx = self.center
  39.  
  40.     # 在指定位置绘制飞船
  41.     def blitme(self):
  42.         self.screen.blit(self.image, self.rect)
  43.  
  44.     # 让飞船在屏幕上居中
  45.     def center_ship(self):
  46.         self.center = self.screen_rect.centerx

alien.py

外星人的初始信息（在屏幕上面显示的位置）和移动。

  1. import pygame
  2. from pygame.sprite import Sprite
  3.  
  4.  
  5. # 表示单个外星人的类
  6. class Alien(Sprite):
  7.     # 初始化外星人并设置起始位置
  8.     def __init__(self, ai_settings, screen):
  9.         super(Alien, self).__init__()
  10.         self.screen = screen
  11.         self.ai_settins = ai_settings
  12.  
  13.         # 加载外星人图像，并设置其rect属性
  14.         self.image = pygame.image.load('images/alien.png')
  15.         self.rect = self.image.get_rect()
  16.  
  17.         # 每个外星人最初都在屏幕左上角附近
  18.         self.rect.x = self.rect.width
  19.         self.rect.y = self.rect.height
  20.  
  21.         # 存储外星人的准确位置
  22.         self.x = float(self.rect.x)
  23.  
  24.     # 在指定位置绘制外星人
  25.     def blitme(self):
  26.         self.screen.blit(self.image, self.rect)
  27.  
  28.     # 向右、左移动外星人
  29.     def update(self):
  30.         # self.x += self.ai_settins.alien_speed_factor
  31.         self.x += (self.ai_settins.alien_speed_factor * self.ai_settins.fleet_direction)
  32.         self.rect.x = self.x
  33.  
  34.     # 如果外星人位于屏幕边缘，就返回True
  35.     def check_edges(self):
  36.         screen_rect = self.screen.get_rect()
  37.         if self.rect.right >= screen_rect.right:
  38.             return True
  39.         elif self.rect.left <= 0:
  40.             return True

bullet.py

子弹的显示和移动。

  1. import pygame
  2. from pygame.sprite import Sprite
  3.  
  4.  
  5. # 一个对飞船发射的子弹进行管理的类
  6. class Bullet(Sprite):
  7.     # 在飞船所处的位置创建一个子弹对象
  8.     def __init__(self, ai_settings, screen, ship):
  9.         super(Bullet, self).__init__()
  10.         self.screen = screen
  11.  
  12.         # 在(0,0)处创建一个表示子弹的矩形，在设置正确的位置
  13.         self.rect = pygame.Rect(0, 0, ai_settings.bullet_width, ai_settings.bullet_height)
  14.         self.rect.centerx = ship.rect.centerx
  15.         self.rect.top = ship.rect.top
  16.  
  17.         # 存储用小数表示的子弹位置
  18.         self.y = float(self.rect.y)
  19.         self.color = ai_settings.bullet_color
  20.         self.speed_factor = ai_settings.bullet_speed_factor
  21.  
  22.     # 向上移动子弹
  23.     def update(self):
  24.         # 更新表示子弹位置的小数值
  25.         self.y -= self.speed_factor
  26.         # 更新表示子弹的rect的位置
  27.         self.rect.y = self.y
  28.  
  29.     # 在屏幕上绘制子弹
  30.     def draw_bullet(self):
  31.         pygame.draw.rect(self.screen, self.color, self.rect)

game_stats.py

游戏是否结束，统计游戏运行期间的变化。

  1. # 跟踪游戏的统计信息
  2. class GameStats():
  3.     # 初始化统计信息
  4.     def __init__(self, ai_settings):
  5.         self.ai_settings = ai_settings
  6.         self.reset_stats()
  7.         # 游戏刚启动时处于非活动状态
  8.         self.game_active = False
  9.         # 在任何情况下都不应重置最高得分
  10.         self.high_score = 0
  11.  
  12.     # 初始化在游戏运行期间可能变化的统计信息
  13.     def reset_stats(self):
  14.         self.ships_left = self.ai_settings.ship_limit
  15.         self.score = 0
  16.         self.level = 1

 button.py

开始按钮

  1. import pygame.font
  2.  
  3.  
  4. class Button():
  5.     # 初始化按钮的属性
  6.     def __init__(self, ai_setting, screen, msg):
  7.         self.screen = screen
  8.         self.screen_rect = screen.get_rect()
  9.  
  10.         # 设置按钮的尺寸和其他属性
  11.         self.width, self.height = 200, 50
  12.         self.button_color = (0, 0, 0)
  13.         self.text_color = (255, 255, 255)
  14.         self.font = pygame.font.SysFont(None, 48)
  15.  
  16.         # 创建按钮的rect的对象，并使其居中
  17.         self.rect = pygame.Rect(0, 0, self.width, self.height)
  18.         self.rect.center = self.screen_rect.center
  19.  
  20.         # 按钮的标签只需创建一次
  21.         self.prep_msg(msg)
  22.  
  23.     # 将msg渲染为图像，并使其在按钮上居中
  24.     def prep_msg(self, msg):
  25.         self.msg_image = self.font.render(msg, True, self.text_color, self.button_color)
  26.         self.msg_image_rect = self.msg_image.get_rect()
  27.         self.msg_image_rect.center = self.rect.center
  28.  
  29.     # 绘制一个用颜色填充的按钮，再绘制文本
  30.     def draw_button(self):
  31.         self.screen.fill(self.button_color, self.rect)
  32.         self.screen.blit(self.msg_image, self.msg_image_rect)

scoreboard.py

当前得分，和最高得分

  1. import pygame.font
  2. from pygame.sprite import Group
  3. from ship import Ship
  4.  
  5.  
  6. # 显示得分信息的类
  7. class Scoreboard():
  8.     def __init__(self, ai_setting, screen, stats):
  9.         self.screen = screen
  10.         self.screen_rect = screen.get_rect()
  11.         self.ai_setting = ai_setting
  12.         self.stats = stats
  13.  
  14.         # 显示得分信息时使用的字体设置
  15.         self.text_color = (30, 30, 30)
  16.         self.font = pygame.font.SysFont(None, 48)
  17.  
  18.         # 准备初始得分图像
  19.         self.prep_score()
  20.         self.prep_high_score()
  21.         self.prep_level()
  22.         self.prep_ships()
  23.  
  24.     # 将得分转换为一幅渲染的图像
  25.     def prep_score(self):
  26.         rounded_score = int(round(self.stats.score, -1))
  27.         score_str = "{:,}".format(rounded_score)
  28.         self.score_image = self.font.render(score_str, True, self.text_color, self.ai_setting.bg_color)
  29.  
  30.         # 将得分放在屏幕右上角
  31.         self.score_rect = self.score_image.get_rect()
  32.         self.score_rect.right = self.screen_rect.right - 20;
  33.         self.score_rect.top = 20
  34.  
  35.     # 在屏幕上显示得分和飞船
  36.     def show_score(self):
  37.         self.screen.blit(self.score_image, self.score_rect)
  38.         self.screen.blit(self.high_score_image, self.high_score_rect)
  39.         self.screen.blit(self.level_image, self.level_rect)
  40.         # 绘制飞船
  41.         self.ships.draw(self.screen)
  42.  
  43.     # 将最高得分转换为渲染的图像
  44.     def prep_high_score(self):
  45.         high_score = int(round(self.stats.high_score, -1))
  46.         high_score_str = "{:,}".format(high_score)
  47.         self.high_score_image = self.font.render(high_score_str, True, self.text_color, self.ai_setting.bg_color)
  48.  
  49.         # 将最高得分放在屏幕顶部中央
  50.         self.high_score_rect = self.high_score_image.get_rect()
  51.         self.high_score_rect.centerx = self.screen_rect.centerx
  52.         self.high_score_rect.top = self.score_rect.top
  53.  
  54.     # 将等级转换为渲染的图像
  55.     def prep_level(self):
  56.         self.level_image = self.font.render(str(self.stats.level), True, self.text_color, self.ai_setting.bg_color)
  57.  
  58.         # 将等级放在得分下方
  59.         self.level_rect = self.level_image.get_rect()
  60.         self.level_rect.right = self.score_rect.right
  61.         self.level_rect.top = self.score_rect.bottom + 10
  62.  
  63.     # 显示还余下多少艘飞船
  64.     def prep_ships(self):
  65.         self.ships = Group()
  66.         for ship_number in range(self.stats.ships_left):
  67.             ship = Ship(self.ai_setting, self.screen)
  68.             ship.rect.x = 10 + ship_number * ship.rect.width
  69.             ship.rect.y = 10
  70.             self.ships.add(ship)

我们的飞船和下面的飞船相撞或者撞到下面的墙都会输出：“Ship hit!!!”(程序中已经注释)

 

 图片可以自己去找，如果想修改图片可以运用电脑的“画图”工具来实现。

总结

主要是记录一下这个，毕竟敲了这么久了，不过还是要理解。

整个游戏的结构还是是否清晰的，游戏的流程储存在alien_invasion中，为了让程序的可读性更好，把功能封装成对应的函数，把这些函数全部储存到game_functions中，把游戏需要初始化的数据（子弹的大小，颜色，速度等等）全部储存到settings中，ship是对飞船的抽象表示，alien是对外星人的抽象表示，bullet是对子弹的抽象表示，通过button来开始游戏，game_stats来记录整个游戏，用scoreboard统计游戏得分。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/121572
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号