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

外星人入侵 python 飞船位置_《python从入门到实践》项目一：外星人入侵

作者：花生_TL007 | 2024-02-21 11:20:58

赞

踩

按下空格才会显示外星人

051a04f7902b8da007619c979c449f0f.png

游戏编程思维导图

  • 游戏思路

58b0f26e3d4ba4a5bdaf560775cf2dc8.png
  • 函数编写

37f4633342105337e9478f076cd7e7dc.png
第一次做思维导图，做的有点乱

解释：跟着《python编程从入门到实践》写完游戏程序后，写一下自己的心得体会。可以把这个游戏分为几块来理解。如果想要设计一款小游戏，第一是对游戏的屏幕进行设置，包括游戏屏幕的大小，背景颜色，背景音乐等（这本书里没有加音乐，以后可以再加）。

设置好游戏屏幕后，第二是对游戏中的元素依次进行设置。首先是飞船，通过载入图片把飞船画在屏幕正下方并使其通过键盘上的左右键进行移动。

第三是子弹：设置一个大小相当的方块，让他初始位置位于初始飞船的顶部，并通过减少Y轴距离向屏幕上方移动，当按下空格键触发子弹移动。（游戏屏幕的左上角位置是（0， 0））同时设置屏幕上同时出现子弹的最大数量，当子弹与外星人碰撞或飞出游戏屏幕外要把子弹删掉。

第四是外星人：游戏是要设置一群外星人不断往下移动，然后飞船射出子弹消灭外星人。所以，在设置外星人时，首先要计算游戏上方区域能容纳多少外星人。通过先画一个外星人，然后再画一圈外星人来实现。画完外星人后，使其初始按右移动，当碰到游戏右界面是向下移动，再向左移动。这时，游戏屏幕上可以显示飞船左右自由移动，按下空格子弹飞出，一群外星人向下移动。

第五是设置游戏开始键：把游戏初始化设置成暂停，当按下开始键后开始玩游戏。

第六是实现碰撞检测：外星人撞到飞船，子弹击中外新人入和外星人碰到游戏界面底部

第七是得分系统：设置消灭外星人的分数，并设置得分显示在屏幕上

第八是提升游戏难度：设置玩家每局有几条命，提高子弹，外星人的移动速度，并把得分，最高分和等级显示在屏幕上

对应函数模块

  • 主函数
  1. # 《外星人入侵》主程序
  2. import sys
  3. import pygame
  4. from pygame.sprite import Group
  5.  
  6. from settings import Settings
  7. from ship import Ship
  8. import game_functions as gf
  9. from alien import Alien
  10. from game_stats import GameStats
  11. from button import Button
  12. from scoreboard import ScoreBoard
  13.  
  14.  
  15. def run_game():
  16.     # 初始化pygame 
  17.     pygame.init()
  18.  
  19.     # 初始化游戏屏幕、游戏名设置，屏幕大小设置时要加括号
  20.     ai_settings = Settings() # 初始设置类的实例化
  21.     screen = pygame.display.set_mode(
  22.         (ai_settings.screen_width, ai_settings.screen_height))
  23.     pygame.display.set_caption("Alien Invasion")
  24.  
  25.     # 创建一艘飞船、一个子弹编组和一个外星人组
  26.     ship = Ship(ai_settings, screen)
  27.     bullets = Group()
  28.     aliens = Group()
  29.  
  30.     # 创建外星人群
  31.     gf.create_fleet(ai_settings, screen, ship, aliens)
  32.  
  33.     # 创建Play按钮
  34.     play_button = Button(ai_settings, screen, "Play")
  35.  
  36.     # 创建一个用于存储游戏统计信息的实例，并创建记分牌
  37.     stats = GameStats(ai_settings)
  38.     sb = ScoreBoard(ai_settings, screen, stats)
  39.  
  40.     # 开始游戏的主循环
  41.     while True:
  42.  
  43.         # 监视键盘和鼠标事件
  44.         gf.check_events(ai_settings, screen, stats, sb, play_button,
  45.             ship, aliens, bullets)
  46.  
  47.         if stats.game_active:
  48.             # 更新飞机移动
  49.             ship.update()
  50.             # 更新子弹
  51.             gf.update_bullets(ai_settings, screen, stats, sb, ship,
  52.                     aliens,bullets)
  53.             # 更新外星人
  54.             gf.update_aliens(ai_settings, screen, stats, sb, ship,
  55.                 aliens, bullets)
  56.  
  57.         # 填充屏幕背景，飞机，并进行刷新
  58.         gf.update_screen(ai_settings, screen, stats, sb, ship,
  59.             aliens, bullets, play_button)
  60.  
  61. run_game()
  • 初始设置
  1. # 创建设置类
  2. class Settings():
  3.     '''存储《外星人入侵》的所有初始设置的参数'''
  4.     def __init__(self):
  5.         '''初始化游戏的设置'''
  6.         '''初始化游戏的静态设置'''
  7.         # 屏幕设置
  8.         self.screen_width = 1200
  9.         self.screen_height = 800
  10.         self.bg_color = (230, 230, 230)
  11.  
  12.         # 设置游戏命数，这样已经是有三条命
  13.         self.ship_limit = 2
  14.         # 设置飞船移动速度
  15.         self.ship_speed_factor = 1.5
  16.  
  17.         # 子弹设置
  18.         self.bullet_width = 3
  19.         self.bullet_height = 15
  20.         self.bullet_color = 60, 60, 60
  21.         # 屏幕上可以同时出现多少颗子弹
  22.         self.bullets_allowed = 6
  23.  
  24.         # 外星人设置
  25.         self.fleet_drop_speed = 10
  26.  
  27.         # 以什么样的速度加快游戏节奏
  28.         self.speedup_scale = 1.1
  29.  
  30.         # 提高外星人分值
  31.         self.score_scale = 1.5
  32.  
  33.         self.initialize_dynamic_settings()
  34.  
  35.     def initialize_dynamic_settings(self):
  36.         '''初始化随游戏进行而变化的设置'''
  37.         self.ship_speed_factor = 1.5
  38.         self.bullet_speed_factor = 3
  39.         self.alien_speed_factor = 1
  40.  
  41.         # 消灭飞船得分
  42.         self.alien_points = 50
  43.  
  44.         # fleet_direction为1表示向右移，-1表示向左移
  45.         self.fleet_direction = 1
  46.  
  47.     def increase_speed(self):
  48.         '''提高速度和外星人分值设置'''
  49.         self.ship_speed_factor *= self.speedup_scale
  50.         self.bullet_speed_factor *= self.speedup_scale
  51.         self.alien_speed_factor *= self.speedup_scale
  52.  
  53.         self.alien_points = int(self.alien_points * self.score_scale)
  • 飞船
  1. # 创建ship类，管理飞船的大部分行为
  2. import pygame
  3. from pygame.sprite import Sprite
  4.  
  5. class Ship(Sprite):
  6.  
  7.     def __init__(self, ai_settings, screen):
  8.         '''初始化飞船并设置其初始位置'''
  9.         super(Ship, self).__init__()
  10.         self.screen = screen
  11.         self.ai_settings = ai_settings
  12.  
  13.         # 加载飞船图像并获取其外接矩形
  14.         self.screen_rect = screen.get_rect()  # 获得屏幕大小参数
  15.         self.image = pygame.image.load(r'images/ship.bmp')
  16.         self.rect = self.image.get_rect()   # 获得飞船图像大小参数
  17.  
  18.         # 将每艘新飞船放在屏幕底部中央
  19.         self.rect.centerx = self.screen_rect.centerx
  20.         self.rect.bottom = self.screen_rect.bottom
  21.  
  22.         # 在飞船的属性center中存储小数值
  23.         self.center = float(self.rect.centerx)  # ????
  24.  
  25.         # 移动标志,初始不可以移动
  26.         self.moving_right = False
  27.         self.moving_left = False
  28.  
  29.     def center_ship(self):
  30.         '''让飞船在屏幕上居中'''
  31.         self.center = self.screen_rect.centerx    
  32.  
  33.     def update(self):
  34.         '''根据移动标志调整飞船的位置，使飞船可以移动'''
  35.         # 更新飞船的center值，而不是rect，并且考虑飞船移动的范围
  36.         if self.moving_right and self.rect.right < self.screen_rect.right:
  37.             self.center += self.ai_settings.ship_speed_factor
  38.         if self.moving_left and self.rect.left > 0:
  39.             self.center -= self.ai_settings.ship_speed_factor
  40.  
  41.         # 根据self.center更新rect对象
  42.         self.rect.centerx = self.center
  43.  
  44.     def blitme(self):
  45.         '''在指定位置绘制飞船'''
  46.         self.screen.blit(self.image, self.rect)
  • 子弹
  1. # 创建子弹
  2. import pygame
  3. from pygame.sprite import Sprite
  4.  
  5. class Bullet(Sprite):
  6.     '''一个对飞船发射的子弹进行管理的类'''
  7.  
  8.     def __init__(self, ai_settings, screen, ship):
  9.         '''在飞船所处的位置创建一个子弹对象'''
  10.         super(Bullet, self).__init__()
  11.         self.screen = screen
  12.  
  13.         # 在（0， 0）处创建一个表示子弹的矩形，再设置正确的位置
  14.         self.rect = pygame.Rect(0, 0, ai_settings.bullet_width,
  15.             ai_settings.bullet_height)
  16.         self.rect.centerx = ship.rect.centerx
  17.         self.rect.top = ship.rect.top
  18.  
  19.         # 存储用小数表示的子弹位置
  20.         self.y = float(self.rect.y)
  21.  
  22.         self.color = ai_settings.bullet_color
  23.         self.speed_factor = ai_settings.bullet_speed_factor
  24.  
  25.     def update(self):
  26.         '''向上移动子弹'''
  27.         # 更新表示子弹位置的小数值
  28.         self.y -= self.speed_factor
  29.         # 更新表示子弹的rect的位置
  30.         self.rect.y = self.y
  31.  
  32.     def draw_bullet(self):
  33.         """画子弹"""
  34.         pygame.draw.rect(self.screen, self.color, self.rect)
  • 外星人
  1. # 创建外星人
  2. import pygame
  3. from pygame.sprite import Sprite
  4.  
  5. class Alien(Sprite):
  6.     '''表示单个外星人的类'''
  7.  
  8.     def __init__(self, ai_settings, screen):
  9.         '''初始化外星人并设置起始位置'''
  10.         super(Alien, self).__init__()
  11.         self.screen = screen
  12.         self.ai_settings = ai_settings
  13.  
  14.         # 加载外星人图像，并设置其rect属性
  15.         self.image = pygame.image.load('images/alien.bmp')
  16.         self.rect = self.image.get_rect()
  17.  
  18.         # 每个外星人初始都在屏幕左上角附近
  19.         self.rect.x = self.rect.width
  20.         self.rect.y = self.rect.height
  21.  
  22.         # 存储外星人的准确位置
  23.         self.x = float(self.rect.x)
  24.  
  25.     def update(self):
  26.         '''向右移动外星人'''
  27.         self.x += (self.ai_settings.alien_speed_factor *
  28.                    self.ai_settings.fleet_direction)
  29.         self.rect.x = self.x
  30.  
  31.     def check_edges(self):
  32.         '''如果外星人位于屏幕边缘，就返回True'''
  33.         screen_rect = self.screen.get_rect()
  34.         if self.rect.right >= screen_rect.right:
  35.             return True   # 用于分函数的判断
  36.         elif self.rect.left <= 0:
  37.             return True
  38.  
  39.     def blitme(self):
  40.         '''在指定位置绘制外星人'''
  41.         self.screen.blit(self.image, self.rect)
  • 按钮
  1. # 创建游戏按钮
  2. import pygame.font
  3.  
  4. class Button():
  5.  
  6.     def __init__(self, ai_settings, screen, msg):
  7.         '''初始化按钮的属性'''
  8.         self.screen = screen
  9.         self.screen_rect = screen.get_rect()
  10.  
  11.         # 设置按钮的尺寸和其他属性
  12.         self.width, self.height = 200, 50
  13.         self.button_color = (0, 255, 0)
  14.         self.text_color = (255, 255, 255)
  15.         self.font = pygame.font.SysFont(None, 48)
  16.  
  17.         # 创建按钮的rect对象，并使其居中
  18.         self.rect = pygame.Rect(0, 0, self.width, self.height)
  19.         self.rect.center = self.screen_rect.center
  20.  
  21.         # 按钮的标签只需创建一次
  22.         self.prep_msg(msg)
  23.  
  24.     def prep_msg(self, msg):
  25.         '''将msg渲染为图像，并使其在按钮上居中'''
  26.         self.msg_image = self.font.render(msg, True, self.text_color,
  27.             self.button_color)
  28.         self.msg_image_rect = self.msg_image.get_rect()
  29.         self.msg_image_rect.center = self.rect.center
  30.  
  31.     def draw_button(self):
  32.         '''绘制一个用颜色填充的按钮，在绘制文本'''
  33.         self.screen.fill(self.button_color, self.rect)
  34.         self.screen.blit(self.msg_image, self.msg_image_rect)
  • 得分系统
  1. # 创建游戏的统计信息
  2.  
  3. class GameStats():
  4.     '''跟踪游戏的统计信息'''
  5.  
  6.     def __init__(self, ai_settings):
  7.         '''初始化统计信息'''
  8.         self.ai_settings = ai_settings
  9.         self.reset_stats()
  10.  
  11.         # 让游戏一开始处于非活跃状态
  12.         self.game_active = False
  13.  
  14.         # 在任何情况下都不应该重置最高得分
  15.         self.high_score = 0
  16.  
  17.     def reset_stats(self):
  18.         '''初始化在游戏运行期间可能变化的统计信息'''
  19.         self.ships_left = self.ai_settings.ship_limit
  20.         self.score = 0
  21.         self.level = 1
  • 得分面板
  1. # 在屏幕上显示得分信息
  2. import pygame.font
  3. from pygame.sprite import Group
  4.  
  5. from ship import Ship
  6.  
  7. class ScoreBoard():
  8.     '''显示得分信息的类'''
  9.  
  10.     def __init__(self, ai_settings, screen, stats):
  11.         '''初始化显示得分涉及的属性'''
  12.         self.screen = screen
  13.         self.screen_rect = screen.get_rect()
  14.         self.ai_settings = ai_settings
  15.         self.stats = stats
  16.  
  17.         # 显示得分信息时使用的字体设置
  18.         self.text_color = (30, 30, 30)
  19.         self.font = pygame.font.SysFont(None, 48)
  20.  
  21.         # 准备初始得分和最高得分、等级和游戏命数图像
  22.         self.prep_score()
  23.         self.prep_high_score()
  24.         self.prep_level()
  25.         self.prep_ships()
  26.  
  27.     def prep_score(self):
  28.         '''将得分转换为一幅渲染的图案'''
  29.         rounded_score = round(self.stats.score, -1)
  30.         # 将得分在千分位插入逗号
  31.         score_str = "{:,}".format(rounded_score)
  32.         self.score_image = self.font.render(score_str, True,
  33.             self.text_color, self.ai_settings.bg_color)
  34.  
  35.         # 将得分放在屏幕右上角
  36.         self.score_rect = self.score_image.get_rect()
  37.         self.score_rect.right = self.screen_rect.right - 20
  38.         self.score_rect.top = 20
  39.  
  40.     def prep_high_score(self):
  41.         '''将最高得分转换为渲染的图案'''
  42.         high_score = round(self.stats.high_score, -1)
  43.         high_score_str = "{:,}".format(high_score)
  44.         self.high_score_image = self.font.render(high_score_str, True,
  45.             self.text_color, self.ai_settings.bg_color)
  46.  
  47.         # 将最高得分放在屏幕顶部中央
  48.         self.high_score_rect = self.high_score_image.get_rect()
  49.         self.high_score_rect.centerx = self.screen_rect.centerx
  50.         self.high_score_rect.top = self.score_rect.top
  51.  
  52.     def prep_level(self):
  53.         '''将等级转换为渲染的图像'''
  54.         self.level_image = self.font.render(str(self.stats.level),
  55.             True, self.text_color, self.ai_settings.bg_color)
  56.  
  57.         #将等级放在得分下方
  58.         self.level_rect = self.level_image.get_rect()
  59.         self.level_rect.right = self.score_rect.right
  60.         self.level_rect.top = self.score_rect.bottom + 10
  61.  
  62.     def prep_ships(self):
  63.         '''显示还剩余多少艘飞船'''
  64.         self.ships = Group()
  65.         for ship_number in range(self.stats.ships_left):
  66.             ship = Ship(self.ai_settings, self.screen)
  67.             ship.rect.x = 10 + ship_number * ship.rect.width
  68.             ship.rect.y = 10
  69.             self.ships.add(ship)
  70.  
  71.     def show_score(self):
  72.         '''在屏幕上显示飞船和得分'''
  73.         self.screen.blit(self.score_image, self.score_rect)
  74.         self.screen.blit(self.high_score_image, self.high_score_rect)
  75.         self.screen.blit(self.level_image, self.level_rect)
  76.         # 绘制显示命的飞船
  77.         self.ships.draw(self.screen)
  • 重构函数
  1. # 重构模块：将一些函数代码分离主函数，主函数简易可观察，分函数修改更方便
  2. import sys
  3. import pygame
  4. from time import sleep
  5.  
  6. from bullet import Bullet
  7. from alien import Alien
  8. from ship import Ship
  9.  
  10.  
  11. '''飞船移动，子弹发射'''
  12.  
  13. def check_events(ai_settings, screen, stats, sb, play_button, ship,
  14.     aliens, bullets):
  15.     '''响应按键和鼠标事件'''
  16.     for event in pygame.event.get():
  17.         if event.type == pygame.QUIT:
  18.             pygame.quit()
  19.             sys.exit()
  20.         elif event.type == pygame.KEYDOWN:
  21.             check_keydown_events(event, ai_settings, screen, ship, bullets)   
  22.         elif event.type == pygame.KEYUP:
  23.             check_keyup_events(event, ship)
  24.         elif event.type == pygame.MOUSEBUTTONDOWN:
  25.             mouse_x, mouse_y = pygame.mouse.get_pos()
  26.             check_play_button(ai_settings, screen, stats, sb, play_button,
  27.                 ship, aliens, bullets, mouse_x, mouse_y)
  28.  
  29. def check_keydown_events(event, ai_settings, screen, ship, bullets):
  30.     '''对键盘操作做出反应'''
  31.     if event.key == pygame.K_RIGHT:
  32.         ship.moving_right = True
  33.     elif event.key == pygame.K_LEFT:
  34.         ship.moving_left = True
  35.     elif event.key == pygame.K_SPACE:
  36.         fire_bullet(ai_settings, screen, ship, bullets)
  37.     elif event.key == pygame.K_q:
  38.         pygame.quit()
  39.         sys.exit()
  40.  
  41. def fire_bullet(ai_settings, screen, ship, bullets):
  42.     # 创建新子弹，并将其加入到编组bullets中
  43.     # 如果还没有到达限制，就发射一颗子弹
  44.     if len(bullets) < ai_settings.bullets_allowed:
  45.         new_bullet = Bullet(ai_settings, screen, ship)
  46.         bullets.add(new_bullet)
  47.  
  48. def check_keyup_events(event, ship):
  49.     '''对松开键盘按键的反应'''
  50.     if event.key == pygame.K_RIGHT:
  51.         ship.moving_right = False
  52.     elif event.key == pygame.K_LEFT:
  53.         ship.moving_left = False
  54.  
  55.  
  56. '''外星人数量设置'''
  57.  
  58. def get_number_aliens_x(ai_settings, alien_width):
  59.     '''计算每行可容纳多少外星人'''
  60.     available_space_x = ai_settings.screen_width - 2 * alien_width
  61.     number_aliens_x = int(available_space_x / (2 * alien_width))    
  62.     return number_aliens_x
  63.  
  64. def get_number_rows(ai_settings, ship_height, alien_height):
  65.     '''计算屏幕可容纳多少外星人'''
  66.     available_space_y = (ai_settings.screen_height - 
  67.                          (3 * alien_height) - ship_height)
  68.     number_rows = int(available_space_y / (2 * alien_height))
  69.     return number_rows
  70.  
  71. def create_alien(ai_settings, screen, aliens, alien_number, row_number):
  72.     '''创建一个外星人并将其放在当前行'''
  73.     alien = Alien(ai_settings, screen)
  74.     alien_width = alien.rect.width
  75.     alien.x = alien_width + 2 * alien_width * alien_number
  76.     alien.rect.x = alien.x
  77.     alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
  78.     aliens.add(alien)    
  79.  
  80. def create_fleet(ai_settings, screen, ship, aliens):
  81.     '''创建外星人群'''
  82.     # 创建一个外星人，并计算一行可容纳多少个外星人
  83.     alien = Alien(ai_settings, screen)
  84.     number_aliens_x = get_number_aliens_x(ai_settings, alien.rect.width)
  85.     number_rows = get_number_rows(ai_settings, ship.rect.height,
  86.         alien.rect.height)
  87.  
  88.     # 创建外星人群
  89.     for row_number in range(number_rows):
  90.         for alien_number in range(number_aliens_x):
  91.             create_alien(ai_settings, screen, aliens, alien_number, row_number)
  92.  
  93.  
  94. '''外星人移动'''
  95.  
  96. def check_fleet_edges(ai_settings, aliens):
  97.     '''有外星人到达边缘时采取相应措施'''
  98.     for alien in aliens.sprites():
  99.         if alien.check_edges():
  100.             change_fleet_direction(ai_settings, aliens)
  101.             break
  102.  
  103. def change_fleet_direction(ai_settings, aliens):
  104.     '''将整群外星人下移，并改变他们的方向'''
  105.     for alien in aliens.sprites():
  106.         alien.rect.y += ai_settings.fleet_drop_speed
  107.     ai_settings.fleet_direction *= -1
  108.  
  109.  
  110. '''碰撞检测'''
  111.  
  112. def ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets):
  113.     '''响应被外星人撞到的飞船'''
  114.     if stats.ships_left > 0:
  115.         # 将ships_left减1
  116.         stats.ships_left -= 1
  117.         # 更新记分牌
  118.         sb.prep_ships()        
  119.     else:
  120.         stats.game_active = False
  121.         pygame.mouse.set_visible(True)
  122.  
  123.     # 清空外星人列表和子弹列表
  124.     aliens.empty()
  125.     bullets.empty()
  126.  
  127.     # 创建一群新的外星人，并将飞船放到屏幕低端中央
  128.     create_fleet(ai_settings, screen, ship, aliens)
  129.     ship.center_ship()
  130.  
  131.     # 暂停
  132.     sleep(1)
  133.  
  134. def check_bullet_alien_collisions(ai_settings, screen, stats, sb, ship,
  135.         aliens, bullets):
  136.     '''响应子弹和外星人的碰撞'''
  137.     # 删除发生碰撞的子弹和外星人
  138.     collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)
  139.  
  140.     if collisions:
  141.         for aliens in collisions.values():
  142.             stats.score += ai_settings.alien_points * len(aliens)
  143.             sb.prep_score()
  144.         check_high_score(stats, sb)
  145.  
  146.     if len(aliens) == 0:
  147.         # 如果整群外星人被消灭，就提高一级
  148.         bullets.empty()
  149.         ai_settings.increase_speed()
  150.  
  151.         # 提高等级
  152.         stats.level += 1
  153.         sb.prep_level()
  154.  
  155.         create_fleet(ai_settings, screen, ship, aliens)
  156.  
  157. def check_aliens_bottom(ai_settings, screen, stats, sb, ship, aliens, bullets):
  158.     '''检查是否有外星人到达了屏幕底端'''
  159.     screen_rect = screen.get_rect()
  160.     for alien in aliens.sprites():
  161.         if alien.rect.bottom >= screen_rect.bottom:
  162.             # 像飞船被撞到一样进行处理
  163.             ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets)
  164.             # 只要有一个外星人到达底部就输了，所有直接退出循环
  165.             break
  166.  
  167.  
  168. '''更新屏幕信息'''
  169.  
  170. def update_bullets(ai_settings, screen, stats, sb, ship, aliens, bullets):
  171.     '''更新子弹的位置，并删除已消失的子弹'''
  172.     bullets.update()
  173.  
  174.     # 删除屏幕外的子弹
  175.     for bullet in bullets.copy():
  176.         if bullet.rect.bottom <= 0:
  177.             bullets.remove(bullet)
  178.  
  179.     check_bullet_alien_collisions(ai_settings, screen, stats, sb, ship,
  180.         aliens, bullets)
  181.  
  182. def update_aliens(ai_settings, screen, stats, sb, ship, aliens, bullets):
  183.     '''检查是否有外星人位于屏幕边缘，并更新整群外星人的位置'''
  184.     check_fleet_edges(ai_settings, aliens)
  185.     aliens.update()
  186.  
  187.     #检测外星人和飞船之间的碰撞
  188.     if pygame.sprite.spritecollideany(ship, aliens):
  189.         ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets)
  190.  
  191.     # 检查是否有外星人到达屏幕底端
  192.     check_aliens_bottom(ai_settings, screen, stats, sb, ship,
  193.         aliens, bullets)  
  194.  
  195. def check_high_score(stats, sb):
  196.     '''检查是否诞生新的最高得分'''
  197.     if stats.score > stats.high_score:
  198.         stats.high_score = stats.score
  199.         sb.prep_high_score()
  200.  
  201. def check_play_button(ai_settings, screen, stats, sb, play_button,
  202.     ship, aliens, bullets, mouse_x, mouse_y):
  203.     '''在玩家点击play按钮时开始游戏'''
  204.     botton_click = play_button.rect.collidepoint(mouse_x, mouse_y)
  205.     if botton_click and not stats.game_active:
  206.         # 重置游戏设置
  207.         ai_settings.initialize_dynamic_settings()
  208.         # 隐藏光标
  209.         pygame.mouse.set_visible(False)
  210.         #重置游戏统计信息
  211.         stats.reset_stats()
  212.         stats.game_active = True
  213.  
  214.         # 重置记分牌图像
  215.         sb.prep_score()
  216.         sb.prep_level()
  217.         sb.prep_ships()
  218.  
  219.         # 清空外星人和子弹列表
  220.         aliens.empty()
  221.         bullets.empty()
  222.  
  223.         # 创建一群新的外星人，并让飞船居中
  224.         create_fleet(ai_settings,screen, ship, aliens)
  225.         ship.center_ship()
  226.  
  227. def update_screen(ai_settings, screen, stats, sb, ship,
  228.     aliens, bullets, play_button):
  229.     '''更新屏幕上的图像，并切换到新屏幕'''
  230.     # 用设置的背景色填充窗口
  231.     # 填充背景后再画飞船，确保飞船在背景前面
  232.     screen.fill(ai_settings.bg_color)
  233.  
  234.     # 在飞船和外星人后面重绘所有子弹
  235.     for bullet in bullets.sprites():
  236.         bullet.draw_bullet()
  237.     ship.blitme()
  238.     aliens.draw(screen)
  239.  
  240.     # 显示得分
  241.     sb.show_score()
  242.  
  243.     # 如果游戏处于非活跃状态，就会绘制Play按钮
  244.     # 放在最后绘制，覆盖在其他图案上
  245.     if not stats.game_active:
  246.         play_button.draw_button()
  247.  
  248.     # 让最近绘制的图像屏幕上可见
  249.     pygame.display.flip()

用到的图片

  • 飞船

0e955f0c4daa8f3587d6c43f7a500279.png
  • 外星人

08583be9f9b5912e4cd32090f96d28f9.png

总结

经过上面代码的锻炼，让我对于写游戏代码有了一点小小的感悟。明白了在设置游戏时需要先把界面里的元素进行分割，每个部分去完成实现。就像上面这个项目，在编写函数依次去实现不同功能：

93ea362f0e860b403ad2a50156633de7.png

写代码还是需要多练，有时候一个字符错误可能都要花很长时间去找，复制一遍代码和自己手动输入一遍代码真的是很不一样

强烈推荐typora编辑器，好用方便，很简洁

下面是游戏视频效果，不过鼠标声音有点响

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

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

  

闽ICP备14008679号