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

Pygame:外星人入侵_外星人入侵 bullet

作者：IT小白 | 2024-02-21 11:00:39

赞

踩

外星人入侵 bullet

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

 

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

文档说明：

        

  1. 游戏主文件夹:alien_invasion
  2. 项目规划:
  3.     玩家控制一艘最初出现在屏幕底部中央的飞船
  4.     操作说明:
  5.         使用箭头键左右移动飞船
  6.         使用空格键射击
  7.     游戏开始时,一群外星人出现在天空中,并向屏幕下方移动,玩家的任务是射杀这些外星人
  8.     玩家将所有外星人消灭干净后,将出现一群新的,并且移动速度更快
  9.     只要有外星人撞到玩家的飞船或者到达屏幕底部,玩家就损失一条飞船
  10.     玩家一共有三艘飞船
  11.  
  12. 使用的第三方模块:pygame
  13.  
  14. .py文件说明:
  15.     alien_invasion.py 游戏主控文件
  16.     setting.py  设置类所在的模块
  17.     ship.py  飞船类所在文件
  18.     bullet.py 子弹类所在的文件
  19.     alien.py 外星人类所在文件
  20.     button.py 存放按钮的类
  21.     game_stats.py 存放游戏统计信息的类
  22.  
  23. 重构方法:
  24.     在大型项目中,经常在添加新代码前重构既有代码,旨在简化既有代码结构,使其更容易扩展.
  25.     本程序需要把越来越长run_game()拆分成一些辅助方法,
  26.         辅助方法一般以单个下划线打头
  27.         _check_events():事件循环
  28.         _update_screen():更新屏幕
  29.  
  30. 持续移动:
  31.     设置移动标志:moving_left和moving_right
  32.     在事件循环中仅改变移动标志
  33.     在ship类中添加updata方法
  34.     在run_game的主循环调用ship.update()
  35. 移动速度:
  36.     在Settings类设置
  37.     修改ship的update方法
  38.     注意self.x 的目的是使得x属性能存储浮点数值
  39.  
  40. 限制飞船的活动范围
  41.     修改ship类的update()方法
  42.     判断是否超出屏幕范围
  43.  
  44. 重构_check_enents():
  45.     将keydown和keyup的事件分开
  46.  
  47. 按Q键退出:
  48.     写入_check_keydown_events()
  49.  
  50. 在全屏模式运行游戏
  51.     修改主程序__init__
  52.  
  53. 射击:
  54.     按空格键发射子弹(用小矩形表示),子弹在屏幕中向上飞行,抵达边缘后消失
  55.     为此新建一个bullet.py的文件
  56.  
  57. 将子弹存储到编组中:
  58.     在主程序中通过pygame.sprite.Group创建一个编组,用于管理所有发射出去的子弹
  59.     对编组调用update()时,精灵自动对编组中的每一个对象调用update()
  60. 开火:
  61.     在_check_keydown_events中编写按下空格键发射一颗子弹
  62.     编写一个新的方法_fire_bullet()来完成这个任务
  63.  
  64. 子弹的删除:
  65.     游戏过程中,产生的子弹超出屏幕时,并没有消失.这将导致资源消耗
  66.     在游戏主循环中删除超出范围的子弹
  67.     使用self.bullet.rect.bottom<=0来判断是否超出屏幕范围
  68. 限制子弹数量:
  69.     在settings中设置允许子弹的数量
  70.     在创建子弹前先判断子弹数量是否小于设置值
  71.  
  72. 创建方法_update_bullets()管理子弹代码,使得主程序的代码简洁
  73.  
  74. 第二部分:外星人
  75.     在屏幕左上角添加一个外星人,并指定合适的边距
  76.     根据第一个外星人的边距和屏幕尺寸计算屏幕上可以容纳多少个外星人,编写一个循环来创建一系列外星人
  77.     让外星人群向两边和下方移动,直到外星人撞到飞船或抵达屏幕下方
  78.     如果外形人群全部被击落,再将创建一群外星人
  79.     如果外星人撞到飞船或者抵达屏幕下方,玩家损失一搜飞船
  80.     限制玩家飞船数量,飞船耗尽,游戏结束
  81.  
  82. 新建文件alien.py,存储外星人类Alien
  83.     Alien不需要在屏幕上绘制外星人的方法,而是通过pygame的编组方法,
  84.     自动在屏幕上绘制编组中的所有元素
  85. 绘制一群外星人
  86.     确定一行可以容纳多少个外星人
  87.     available_space_x = settings.screen_width - (2*alien_width)
  88.     让外星人之间空一个外星人的距离
  89.     numbers_aliens_x = available_space_x //(2*alien_width)
  90.     重写_create_fleet让其创建一群外星人
  91. 重构_create_fleet:
  92.     添加_create_alien
  93.  
  94. 添加行:
  95.     计算能容纳几行外星人
  96.     available_space_y = settings.screen_height - (3*alien_height) -ship_height
  97.     number_rows = available_space_y // (2*alien_height)
  98. 让外星人移动
  99.     让外星人向右移动,撞到屏幕边缘后下移一定的量,再沿相反的方向移动
  100. 检查外星人是否移动到了屏幕边缘
  101.     check_edges()
  102.  
  103. 向下移动外星人并改变方向
  104.     编写方法_check_fleet_edges
  105.             _change_fleet_direction
  106.             修改_update_aliens
  107.  
  108. 射杀外星人
  109.     碰撞检测
  110.         使用sprite.groupcollide()检测
  111.         检测子弹和外星人的碰撞
  112.             将子弹的rect和外星人的rect比较,并返回一个字典
  113.             其中包含发生碰撞的子弹和外星人{子弹x:外星人y}
  114. 为测试创建大子弹
  115.     修改设置
  116.         如子弹速度,子弹大小等
  117. 生成新的外形人群
  118.     在_update_bullets中增加
  119.     如果aliens为空
  120.     调用_create_fleet()来新增
  121. 重构_update_bullets
  122.     将处理子弹和外星人碰撞的代码移动到一个独立的函数中_check_bullet_alien_collisions()
  123.  
  124. 检测外星人和飞船碰撞
  125.     在更新外星人后,立即检测外星人和飞船的碰撞
  126.     所以代码加在_update_aliens()后面
  127.  
  128. 新建类GameStats,用于跟踪游戏统计信息
  129. 新增方法_ship_hit()处理当外星人撞到飞船时做的事情
  130. 将新增方法放在_update_aliens(self)中
  131.     同时新增ship类辅助方法center_ship(self)
  132.  
  133. 有外星人到达屏幕底部:
  134.     为检测这种情况,在主程序中添加 _check_aliens_bottom()方法
  135.  
  136. 结束游戏:
  137.     在GameStats中添加一个标志game_active
  138.     当ships_left==0时结束游戏
  139.     在_ship_hit()方法中改变标志game_active
  140.     确定哪些部分在game_active为真状态下才运行
  141.  
  142. 第三部分 记分
  143.     添加play按钮
  144.         在游戏开始前和结束后出现,用于玩家开始游戏
  145.         修改状态信息类game_stats,开始时设置为false
  146.         创建button类
  147.         在屏幕上绘制按钮
  148.             在主程序import中导入按钮类
  149.             在__init__实例化一个按钮
  150.             在_update_screen中绘制
  151.         开始游戏
  152.             在_check_events()添加代码块,监视与该按钮有关的鼠标事件
  153.         重置游戏
  154.             游戏因耗尽飞船结束时,应再次出现play按钮
  155.             并重置统计信息,删除现有的外星人和子弹
  156.             创建一群新的外星人并让飞船居中
  157.         将play按钮切换到非活动状态
  158.             游戏开始后虽然看不见paly按钮,但是鼠标点击那个位置还是会触发点击事件
  159.             可以让游戏状态仅在false时才开始
  160.         隐藏鼠标光标
  161.             在_check_play_button添加代码
  162.             游戏结束添加光标,在_ship_hit添加代码
  163.  
  164.  
  165.     随着等级提高加快节奏,提升难度
  166.         将设置分为静态设置和动态设置
  167.         增加初始化速度和改变速度的方法
  168.         在_check_bullet_alien_collisions()中调用设置的增加速度的方法increase_speed
  169.  
  170.         重置速度
  171.         开始游戏时应该重置速度
  172.         在方法_check_play_button添加代码
  173.  
  174.     记分系统
  175.         实时跟踪玩家的得分,并显示最高得分,等级,剩余飞船数量
  176.         在gameStats中添加score属性
  177.  
  178.         在屏幕上显示得分
  179.             创建一个新类scoreboard
  180.         创建记分牌
  181.             在主程序创建一个scoreboard实例
  182.             在_update_screen方法中绘制记分牌
  183.         在外星人被消灭时更新得分
  184.             在_check_bullet_alien_collisions添加代码
  185.  
  186.         调整外星人和子弹碰撞的方式,让每一个被消灭的外星人都能带来积分
  187.         舍入得分
  188.  
  189.         最高得分
  190.         将最高分存储在GameStats中
  191.  
  192.         显示等级
  193.  
  194.         显示剩余飞船数
  195. bug:
  196.     1.严格地来说应该叫做失误>>>
  197.         在bullet.py中的update()方法中错误地将self.rect.y = self.y写成了
  198.         self.rect = self.y导致绘制矩形的时候出现TypeError: rect argument is invalid
  199.  
  200.  
  201.  
  202.

主文件：

alien_invasion.py
  1. # alien_invasion.py
  2. import sys
  3. from time import sleep
  4. import pygame
  5. from settings import Settings
  6. from game_stats import GameStats
  7. from ship import Ship
  8. from bullet import Bullet
  9. from alien import Alien
  10. from button import Button
  11. from scoreboard import ScoreBoard
  12.  
  13. class AlienInvasion:
  14.     '''管理游戏资源和行为的类'''
  15.  
  16.     def __init__(self):
  17.         '''初始化游戏并创建游戏资源'''
  18.         pygame.init()
  19.         self.settings = Settings()
  20.         # 全屏模式
  21.         self.screen = pygame.display.set_mode((0,0),pygame.FULLSCREEN) # 全屏
  22.         # self.screen = pygame.display.set_mode((self.settings.screen_width,self.settings.screen_height))  # surface
  23.         self.settings.screen_width = self.screen.get_rect().width
  24.         self.settings.screen_height = self.screen.get_rect().height
  25.         pygame.display.set_caption('Alien Invasion')
  26.         self.stats = GameStats(self)
  27.         #创建记分牌
  28.         self.scoreboard = ScoreBoard(self)
  29.         self.ship = Ship(self)
  30.         self.bullets = pygame.sprite.Group()
  31.         self.aliens = pygame.sprite.Group()
  32.         self._create_fleet()
  33.         # 创建play按钮
  34.         self.play_button = Button(self,'Play')
  35.  
  36.  
  37.     def run_game(self):
  38.         '''开始游戏的主循环'''
  39.         while True:
  40.             self._check_events()
  41.             if self.stats.game_active:
  42.                 self.ship.update()
  43.                 self._update_bullets()
  44.                 self._update_aliens()
  45.             self._update_screen()
  46.  
  47.  
  48.  
  49.     def _check_events(self):
  50.         '''响应按键和鼠标事件'''
  51.         for event in pygame.event.get():
  52.             if event.type == pygame.QUIT:
  53.                 sys.exit()
  54.             elif event.type == pygame.KEYDOWN:
  55.                 self._check_keydown_events(event)
  56.             elif event.type ==pygame.KEYUP:
  57.                 self._check_keyup_events(event)
  58.             elif event.type == pygame.MOUSEBUTTONDOWN:
  59.                 mouse_pos = pygame.mouse.get_pos()
  60.                 self._check_play_button(mouse_pos)
  61.  
  62.     def _check_play_button(self,mouse_pos):
  63.         '''在玩家单击play时开始新游戏'''
  64.         button_clicked = self.play_button.rect.collidepoint(mouse_pos)
  65.         if button_clicked and not self.stats.game_active:
  66.             # 重置速度
  67.             self.settings.initialize_dynamic_settings()
  68.             # 重置游戏统计信息
  69.             self.stats.reset_stats()
  70.             self.stats.game_active = True
  71.             self.scoreboard.prep_score()
  72.             self.scoreboard.prep_level()
  73.             self.scoreboard.prep_ships()
  74.             # 清空子弹和外星人
  75.             self.aliens.empty()
  76.             self.bullets.empty()
  77.             # 创建新外星人,并让飞船居中
  78.             self._create_fleet()
  79.             self.ship.center_ship()
  80.             # 隐藏鼠标光标
  81.             pygame.mouse.set_visible(False)
  82.  
  83.  
  84.     def _check_keydown_events(self,event):
  85.         '''响应按键'''
  86.         if event.key == pygame.K_RIGHT:
  87.             self.ship.moving_right = True
  88.         elif event.key == pygame.K_LEFT:
  89.             self.ship.moving_left = True
  90.         elif event.key == pygame.K_q:
  91.             sys.exit()
  92.         elif event.key == pygame.K_SPACE:
  93.             self._fire_bullet()
  94.  
  95.     def _check_keyup_events(self,event):
  96.         '''响应松开'''
  97.         if event.key == pygame.K_RIGHT:
  98.             self.ship.moving_right = False
  99.         elif event.key == pygame.K_LEFT:
  100.             self.ship.moving_left = False
  101.  
  102.     def _fire_bullet(self):
  103.         '''创建一颗子弹并将其加入编组self.bullets中'''
  104.         if len(self.bullets) <= self.settings.bullets_allowed:
  105.             new_bullet = Bullet(self)
  106.             self.bullets.add(new_bullet)
  107.  
  108.     def _update_bullets(self):
  109.         '''更新子弹位置并删除消失的子弹'''
  110.         # 更新子弹位置
  111.         self.bullets.update()
  112.         # 删除消失的子弹
  113.         for bullet in self.bullets.copy():
  114.             if bullet.rect.bottom <= 0:
  115.                 self.bullets.remove(bullet)
  116.         # 检查是否有子弹击中了外星人
  117.         # 如果是就删除相应的子弹和外星人
  118.         self._check_bullet_alien_collisions()
  119.  
  120.     def _check_bullet_alien_collisions(self):
  121.         '''响应子弹和外星人碰撞'''
  122.         # 删除发生碰撞的子弹和外星人
  123.         collisions = pygame.sprite.groupcollide(self.bullets, self.aliens, True, True)
  124.         # 参数True指的是碰撞后删除碰撞的元素
  125.         if collisions:
  126.             for aliens in collisions.values():
  127.                 self.stats.score += self.settings.alien_points*len(aliens)
  128.                 # 重绘记分板
  129.                 self.scoreboard.prep_score()
  130.                 self.scoreboard.check_high_score()
  131.         if not self.aliens:
  132.             # 删除现有子弹并新建一群外星人
  133.             self.bullets.empty()
  134.             self._create_fleet()
  135.             #加速
  136.             self.settings.increase_speed()
  137.             # 提高等级
  138.             self.stats.level += 1
  139.             self.scoreboard.prep_level()
  140.  
  141.     def _ship_hit(self):
  142.         '''响应飞船被外星人撞到'''
  143.         # 将ships_left 减1 并更新记分牌
  144.         if self.stats.ships_left > 0:
  145.             self.stats.ships_left -= 1
  146.             self.scoreboard.prep_ships()
  147.             # 清空余下的外星人和 子弹
  148.             self.bullets.empty()
  149.             self.aliens.empty()
  150.             # 创建一群新的外星人并将飞船放到屏幕底部中央
  151.             self._create_fleet()
  152.             self.ship.center_ship()
  153.             # 暂停
  154.             sleep(0.5)
  155.         else :
  156.             self.stats.game_active = False
  157.             # 恢复光标
  158.             pygame.mouse.set_visible(True)
  159.  
  160.  
  161.  
  162.  
  163.     def _update_aliens(self):
  164.         '''检查是否有外星人位于边缘位置
  165.         并更新整群外星人的位置 '''
  166.         self._check_fleet_edges()
  167.         self.aliens.update()
  168.         # 检测外星人和飞船碰撞
  169.         if pygame.sprite.spritecollideany(self.ship,self.aliens):
  170.             # print('飞船被撞了!')  # 控制台打印,说明能检测到
  171.             self._ship_hit()
  172.         # 检查有否有外星人达到屏幕底部
  173.         self._check_aliens_bottom()
  174.  
  175.  
  176.     def _create_fleet(self):
  177.         '''创建外星人群'''
  178.         # 创建一个外星人并计算一行可以容纳多少个外星人
  179.         alien = Alien(self)
  180.         alien_width,alien_height = alien.rect.width,alien.rect.height
  181.         available_space_x = self.settings.screen_width - (2 * alien_width)
  182.         numbers_aliens_x = available_space_x // (2 * alien_width)
  183.         # 计算屏幕可容纳几行外星人
  184.         ship_height = self.ship.rect.height
  185.         available_space_y = self.settings.screen_height - (3 * alien_height) - ship_height
  186.         number_rows = available_space_y // (2 * alien_height)
  187.         # 创建第一行外星人
  188.         # for alien_number in range(numbers_aliens_x):
  189.         #     self.__create_alien(alien_number)
  190.         # 创建外星人群
  191.         for row in range(number_rows):
  192.             for alien_number in range(numbers_aliens_x):
  193.                 self.__create_alien(alien_number,row)
  194.  
  195.     def __create_alien(self,alien_number,row_number):
  196.         # 创建一个外星人,并让其加入当前行
  197.         alien = Alien(self)
  198.         alien_width,alien_height = alien.rect.size
  199.         alien.x = alien_width + 2 * alien_width * alien_number
  200.         alien.rect.x = alien.x
  201.         alien.y = alien.rect.height + 2*alien.rect.height*row_number
  202.         alien.rect.y = alien.y
  203.         self.aliens.add(alien)
  204.  
  205.     def _check_aliens_bottom(self):
  206.         '''检测是否有外星人到达屏幕底部'''
  207.         screen_rect = self.screen.get_rect()
  208.         for alien in self.aliens.sprites():
  209.             if alien.rect.bottom >= screen_rect.bottom:
  210.                 # 像飞船被撞到一样处理
  211.                 self._ship_hit()
  212.                 break
  213.  
  214.  
  215.  
  216.  
  217.     def _check_fleet_edges(self):
  218.         '''有外星人到达边缘时采取对应的措施'''
  219.         for alien in self.aliens.sprites():
  220.             if alien.check_edges():
  221.                 self._change_fleet_direction()
  222.                 break
  223.     def _change_fleet_direction(self):
  224.         '''对整群外星人下移并改变方向'''
  225.         for alien in self.aliens.sprites():
  226.             alien.rect.y += self.settings.fleet_drop_speed
  227.         self.settings.fleet_direction *= -1
  228.  
  229.  
  230.  
  231.  
  232.     def _update_screen(self):
  233.         '''更新屏幕图像并切换到新屏幕'''
  234.         self.screen.fill(self.settings.bg_color)
  235.         self.ship.blitme()
  236.         for bullet in self.bullets.sprites():
  237.             bullet.draw_bullet()
  238.  
  239.         self.aliens.draw(self.screen)
  240.         self.scoreboard.show_score()
  241.         # 当游戏处于非活动状态,就绘制play按钮
  242.         if not self.stats.game_active:
  243.             self.play_button.draw_button()
  244.  
  245.         pygame.display.flip()
  246.  
  247.  
  248.  
  249. """
  250. 说明:
  251.     surface:是屏幕的一部分,用于显示游戏元素"""
  252.  
  253.  
  254. if __name__ == '__main__':
  255.     # 创建游戏实例并运行游戏
  256.     ai = AlienInvasion()
  257.     b = ai.settings
  258.     print(b.bullet_height,b.bullet_width)
  259.     ai.run_game()
  260.  
  261.  
  262.  
  263.

飞船文件：

ship.py

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

外星人：alien.py

  1. # alien.py  外星人类所在文件
  2. import pygame
  3. from pygame.sprite import Sprite
  4. class Alien(Sprite):
  5.     '''表示单个外星人的类'''
  6.     def __init__(self,ai_game):
  7.         '''初始化外星人并设置其初始位置'''
  8.         super().__init__()
  9.         self.screen = ai_game.screen
  10.         self.settings = ai_game.settings
  11.         # 加载外星人图像并设置其rect属性
  12.         self.image = pygame.image.load('images/alien.png')
  13.         self.rect = self.image.get_rect()
  14.         self.rect.x = self.rect.width
  15.         self.rect.y = self.rect.height
  16.         # 存储外星人的精确水平位置
  17.         self.x = float(self.rect.x)
  18.  
  19.     def check_edges(self):
  20.         '''如果外星人位于屏幕边缘就返回True'''
  21.         screen_rect = self.screen.get_rect()
  22.         if self.rect.right >= screen_rect.right \
  23.             or self.rect.left <= 0:
  24.             return True
  25.  
  26.  
  27.     def update(self):
  28.         '''向右移动外星人'''
  29.         self.x += self.settings.alien_speed * self.settings.fleet_direction
  30.         self.rect.x = self.x
  31.

子弹：bullet.py

  1. import pygame
  2. from pygame.sprite import Sprite
  3. class Bullet(Sprite):
  4.     '''管理飞船所发射的子弹的类'''
  5.     def __init__(self,ai_game):
  6.         '''在飞船当前位置创建一个子弹对象'''
  7.         super().__init__()
  8.         self.screen = ai_game.screen
  9.         self.settings = ai_game.settings
  10.         self.color = self.settings.bullet_color
  11.         # 在(0,0)处创建一个表示子弹的矩形,再设置正确的位置
  12.         self.rect = pygame.Rect(0,0,self.settings.bullet_width
  13.                                 ,self.settings.bullet_height)
  14.         self.rect.midtop = ai_game.ship.rect.midtop
  15.         # 存储小数表示的子弹位置
  16.         self.y = float(self.rect.y)
  17.  
  18.     def update(self):
  19.         '''向上移动子弹'''
  20.         # 更新表示子弹位置的小数值
  21.         self.y -= self.settings.bullet_speed
  22.         # 更新表示子弹的rect的位置
  23.         self.rect.y = self.y
  24.  
  25.     def draw_bullet(self):
  26.         '''在屏幕上绘制子弹'''
  27.         pygame.draw.rect(self.screen,self.color,self.rect)
  28.  
  29.  
  30. """
  31. 说明:
  32.     pygame.sprite(精灵)可将游戏中的相关元素编组,进而同时操作编组中的元素
  33. """

设置:settings.py

  1. # settings.py  设置类所在的模块
  2. # 通过类Setting存储游戏所有的设置
  3.  
  4. class Settings:
  5.     '''存储游戏<<外星人入侵>>中所有设置的类'''
  6.  
  7.     def __init__(self):
  8.         '''初始化游戏的静态设置'''
  9.         # 屏幕设置
  10.         self.screen_width = 1200
  11.         self.screen_height = 800
  12.         self.bg_color = (230,230,230)
  13.         # 飞船设置
  14.         # self.ship_speed = 1.5
  15.         self.ship_limit = 3
  16.         # 子弹设置
  17.         # self.bullet_speed = 3
  18.         self.bullet_width = 3
  19.         self.bullet_height = 15
  20.         self.bullet_color = (60,60,60)
  21.         self.bullets_allowed = 3
  22.         # 外星人设置
  23.         # self.alien_speed = 1.0
  24.         self.fleet_drop_speed = 10
  25.         # fleet_direction为1表示右移,-1表示左移
  26.         # self.fleet_direction = 1
  27.         # 加快游戏节奏
  28.         self.speedup_scale = 1.1
  29.         # 外星人分数的提高速度
  30.         self.score_scale = 1.5
  31.         self.initialize_dynamic_settings()
  32.  
  33.     def initialize_dynamic_settings(self):
  34.         '''初始化随游戏进行而变化的设置'''
  35.         self.ship_speed = 1.5
  36.         self.bullet_speed = 3.0
  37.         self.alien_speed = 1.0
  38.         self.fleet_direction = 1
  39.         # 消灭1个外星人的得分
  40.         self.alien_points = 50
  41.  
  42.     def increase_speed(self):
  43.         self.ship_speed *= self.speedup_scale
  44.         self.bullet_speed *= self.speedup_scale
  45.         self.alien_speed *= self.speedup_scale
  46.         self.alien_points = int(self.alien_points * self.score_scale)
  47.         # print(self.alien_points)
  48.  
  49.

统计游戏过程信息

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

按钮:button.py

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

记分板:socreboard.py

  1.  
  2. import pygame.font
  3. from pygame.sprite import Group
  4. from ship import Ship
  5. class ScoreBoard:
  6.     '''显示得分信息的类'''
  7.     def __init__(self,ai_game):
  8.         '''初始化显示得分涉及的属性'''
  9.         self.ai_game = ai_game
  10.         self.screen = ai_game.screen
  11.         self.screen_rect = self.screen.get_rect()
  12.         self.settings = ai_game.settings
  13.         self.stats = ai_game.stats
  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.         # 显示等级
  22.         self.prep_level()
  23.         self.prep_ships()
  24.  
  25.     def prep_ships(self):
  26.         '''显示还余下多少飞船'''
  27.         self.ships = Group()
  28.         for ship_number in range(self.stats.ships_left):
  29.             ship = Ship(self.ai_game)
  30.             ship.rect.x = 10 +ship_number * ship.rect.width
  31.             ship.rect.y = 10
  32.             self.ships.add(ship)
  33.  
  34.     def prep_level(self):
  35.         '''将等级转换为渲染的图像'''
  36.         level_str = str(self.stats.level)
  37.         self.level_img = self.font.render(
  38.             level_str,True,
  39.             self.text_color,self.settings.bg_color)
  40.         # 将等级放在等分下方
  41.         self.level_rect = self.level_img.get_rect()
  42.         self.level_rect.right = self.score_rect.right
  43.         self.level_rect.top = self.score_rect.bottom + 10
  44.  
  45.     def prep_high_score(self):
  46.         '''将最高等分渲染为图像'''
  47.         high_score = round(self.stats.high_score,-1)
  48.         high_score_str = '{:,}'.format(high_score)
  49.         self.high_score_img = self.font.render(high_score_str,True,
  50.                                                self.text_color,self.settings.bg_color)
  51.         # 将最高分放在屏幕中央
  52.         self.high_score_rect = self.high_score_img.get_rect()
  53.         self.high_score_rect.centerx = self.screen_rect.centerx
  54.         self.high_score_rect.top = self.score_rect.top
  55.  
  56.     def prep_score(self):
  57.         '''将得分转化为一幅渲染的图像'''
  58.         rounded_score = round(self.stats.score,-1)
  59.         score_str = '{:,}'.format(rounded_score)
  60.         self.score_img = self.font.render(score_str,True,
  61.                                           self.text_color,self.settings.bg_color)
  62.         # 在屏幕右上角显示得分
  63.         self.score_rect = self.score_img.get_rect()
  64.         self.score_rect.right = self.screen_rect.right -20
  65.         self.score_rect.top = 20
  66.  
  67.     def show_score(self):
  68.         '''在屏幕上显示得分'''
  69.         self.screen.blit(self.score_img,self.score_rect)
  70.         self.screen.blit(self.high_score_img,self.high_score_rect)
  71.         self.screen.blit(self.level_img,self.level_rect)
  72.         self.ships.draw(self.screen)
  73.  
  74.     def check_high_score(self):
  75.         '''检查是否诞生了新的最高分'''
  76.         if self.stats.score > self.stats.high_score:
  77.             self.stats.high_score = self.stats.score
  78.             self.prep_high_score()
  79.

效果:

 一个小游戏,玩的是你

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

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

  

闽ICP备14008679号