💝💝💝欢迎莅临我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。

• 推荐:「stormsha的主页」👈，持续学习，不断总结，共同进步，为了踏实，做好当下事儿~

• 专栏导航

  • Python系列: Python面试题合集，剑指大厂
  • Git系列: Git操作技巧
  • GO系列: 记录博主学习GO语言的笔记，该笔记专栏尽量写的试用所有入门GO语言的初学者
  • 数据库系列: 详细总结了常用数据库 mysql 技术点,以及工作中遇到的 mysql 问题等
  • 运维系列: 总结好用的命令，高效开发
  • 算法与数据结构系列: 总结数据结构和算法,不同类型针对性训练,提升编程思维

    非常期待和您一起在这个小小的网络世界里共同探索、学习和成长。💝💝💝 ✨✨ 欢迎订阅本专栏 ✨✨

    💖The Start💖点点关注，收藏不迷路💖

    📒文章目录

    • 效果图
    • 项目结构
    • 程序代码

      ---

      完整代码：https://gitcode.com/stormsha1/games/overview

      效果图

      

      项目结构

      

      程序代码

      run.py

      import sys  
      import pygame  
      from pygame.locals import KEYDOWN, QUIT, K_q, K_ESCAPE, MOUSEBUTTONDOWN  
      from dissipate.level import Manager  
      from dissipate.level_tree import LevelTreeManager  
      from dissipate.sounds import Sounds  
        
        
      class Game:  
          """  
          游戏主类，负责初始化和主循环  
          """  
          def __init__(self):  
              """  
              初始化游戏  
              """        pygame.init()  
              pygame.mixer.init()  
              pygame.display.set_caption('开心消消乐')  # 设置游戏窗口标题  
              pygame.mouse.set_visible(False)  # 隐藏鼠标指针  
        
              # 初始化游戏管理器和声音  
              self.tree = LevelTreeManager()  # 树管理器，用于主菜单  
              self.manager = Manager(0, 0)  # 游戏管理器，用于处理游戏逻辑  
              self.world_bgm = pygame.mixer.Sound(Sounds.WORLD_BGM.value)  # 世界背景音乐  
              self.game_bgm = pygame.mixer.Sound(Sounds.GAME_BGM.value)  # 游戏背景音乐  
        
              # 提高游戏性能的优化  
              self.get_events = pygame.event.get  # 获取事件的方法  
              self.update_window = pygame.display.flip  # 刷新窗口的方法  
        
              self.sound_sign = 0  # 用于控制背景音乐切换的标志  
        
          def run(self):  
              """主游戏循环"""  
              while True:  
                  self.handle_music()  # 处理背景音乐  
                  self.draw()  # 绘制游戏界面  
                  self.handle_events()  # 处理用户输入事件  
                  self.update()  # 更新显示  
        
          def handle_music(self):  
              """根据游戏级别管理背景音乐"""  
              if self.manager.level == 0:  
                  if self.sound_sign == 0:  
                      self.game_bgm.stop()  # 停止游戏背景音乐  
                      self.world_bgm.play(-1)  # 循环播放世界背景音乐  
                      self.sound_sign = 1  
              else:  
                  if self.sound_sign == 1:  
                      self.world_bgm.stop()  # 停止世界背景音乐  
                      self.game_bgm.play(-1)  # 循环播放游戏背景音乐  
                      self.sound_sign = 0  
        
          def draw(self):  
              """根据级别绘制相应的游戏界面"""  
              if self.manager.level == 0:  
                  self.tree.draw_tree(self.manager.energy_num, self.manager.money)  # 绘制主菜单界面  
              else:  
                  self.manager.set_level_mode(self.manager.level)  # 设置当前关卡模式  
                  sprite_group = self.manager.draw()  # 绘制游戏关卡界面  
                  if self.manager.type == 0:  
                      self.manager.eliminate_animals()  # 消除动物  
                      self.manager.death_map()  # 更新死亡地图  
                      self.manager.swap(sprite_group)  # 处理交换逻辑  
                  self.manager.judge_level()  # 判断关卡状态  
        
          def handle_events(self):  
              """处理用户输入事件"""  
              for event in self.get_events():  
                  if event.type == KEYDOWN:  
                      if event.key in (K_q, K_ESCAPE):  
                          sys.exit()  # 按下 Q 或 ESC 键退出游戏  
                  elif event.type == QUIT:  
                      sys.exit()  # 点击关闭按钮退出游戏  
                  elif event.type == MOUSEBUTTONDOWN:  
                      mouse_x, mouse_y = event.pos  # 获取鼠标点击位置  
                      if self.manager.level == 0:  
                          self.tree.mouse_select(  
                              self.manager, mouse_x,  
                              mouse_y,  
                              self.manager.level,  
                              self.manager.energy_num,  
                              self.manager.money  
                          )  # 处理主菜单鼠标选择  
                      self.manager.mouse_select(mouse_x, mouse_y)  # 处理游戏内鼠标选择  
        
          def update(self):  
              """  
              更新鼠标图像并刷新显示  
              :return:  
              """        self.manager.mouse_image()  # 更新鼠标图像  
              self.update_window()  # 刷新显示  
        
        
      if __name__ == '__main__':  
          game = Game()  # 创建游戏实例  
          game.run()  # 启动游戏
      

      level.py

      import os  
      from random import randint  
      import pygame  
      from pygame.locals import *  
      from pygame.time import delay  
      from dissipate.img import img_basic  
      from dissipate.sounds import Sounds, play_sound  
      from dissipate.sprites import Board, Element  
        
        
      class Manager:  
          """Game manager."""  
          # 游戏屏幕的大小设置为900x600像素  
          __screen_size = (900, 600)  
          # 使用pygame库设置屏幕模式，DOUBLEBUF是双缓冲，32是位深度  
          screen = pygame.display.set_mode(__screen_size, DOUBLEBUF, 32)  
          # 砖块的大小设置为50x50像素  
          __brick_size = 50  
          # 加载背景图片并转换为优化格式  
          __bg = pygame.image.load(os.path.join(img_basic, 'bg.png')).convert()  
          # 停止宽度，可能用于游戏结束或暂停的界面  
          stop_width = 63  
          # 当前选中的砖块位置，格式为[row, col]  
          selected = [-1, -1]  
          # 交换标志，可能用于交换砖块或游戏逻辑  
          swap_sign = -1  
          # 上一次选中的砖块位置，格式为[row, col]  
          last_sel = [-1, -1]  
          # 是否交换的标志，用于判断是否发生了交换  
          value_swapped = False  
          # 死亡地图的标志，可能用于显示或隐藏死亡相关的游戏元素  
          death_sign = True  
          # 消除4个砖块时选中的位置，格式为[row, col]  
          boom_sel = [-1, -1]  
          # 当前关卡，0表示树（可能是特殊关卡或菜单）  
          level = 0  
          # 玩家的金钱数量  
          money = 100  
          # 能量点数  
          energy_num = 30  
          # 数字标志，可能用于显示或隐藏数字相关的游戏元素  
          num_sign = True  
          # 游戏类型，0为进行中，1为通过，-1为失败，2为树  
          type = 2  
          # 是否重置布局的标志  
          reset_mode = True  
          # 每个关卡的初始步数  
          init_step = 15  
          # 当前游戏剩余的步数  
          step = init_step  
          # 玩家的得分  
          score = 0  
          # 中等得分的两个阈值  
          min = 20  
          max = 50  
          # 已消除动物的数量列表，长度为6，可能代表6种不同的动物  
          animal_num = [0, 0, 0, 0, 0, 0]  
          # 剩余需要消除的冰块数量  
          ice_num = 0  
          # 成功板，继承自Board类，位置在[200, 0]  
          success_board = Board(Board.success, [200, 0])  
          # 失败板，继承自Board类，位置在[200, 0]  
          fail_board = Board(Board.fail, [200, 0])  
          # 游戏网格的高度和宽度，都是9  
          height, width = 9, 9  
          # 选中的行和列，初始值为5  
          row, col = 5, 5  
          # 冰块列表，21x21的二维列表，-1表示无冰块，1表示有冰块  
          ice_list = [[-1 for _ in range(21)] for _ in range(21)]  
          # 动物列表，21x21的二维列表，-2表示已消除，-1表示无动物，0-4表示不同的动物  
          animal = [[-1 for _ in range(21)] for _ in range(21)]  
          # 砖块的x和y位置列表，用于确定砖块在屏幕上的位置  
          list_x, list_y = (__screen_size[0] - 11 * __brick_size) / 2, (__screen_size[1] - 11 * __brick_size) / 2  
        
          def __init__(self, width, height):  
              self.height = height  
              self.width = width  
              self.list_x = (Manager.__screen_size[0] - self.width * Manager.__brick_size) / 2  
              self.list_y = (Manager.__screen_size[1] - self.height * Manager.__brick_size) / 2  
              self.row, self.col = Manager.xy_rc(self.list_x, self.list_y)  
              self.list_x, self.list_y = Manager.rc_xy(self.row, self.col)  
              self.ice_list = [[-1 for _ in range(21)] for _ in range(21)]  
              self.animal = [[-1 for _ in range(21)] for _ in range(21)]  
              self.reset_animals()  
        
          def reset_animals(self):  
              """  
              用于将游戏板上的动物随机重置为0到5之间的数字，  
              其中0可能表示没有动物，1到5表示不同类型的动物。  
              """        # 遍历由self.row和self.col确定的起始行和列，直到高度和宽度决定的结束行和列  
              for row in range(self.row, self.row + self.height):  
                  # 对于每一行row，遍历由self.col和self.col + self.width确定的起始列和结束列  
                  for col in range(self.col, self.col + self.width):  
                      # 为当前位置(row, col)随机分配一个动物编号，编号范围从0到5  
                      # randint是random模块中的一个函数，用于生成一个指定范围内的随机整数  
                      self.animal[row][col] = randint(0, 5)  
        
          @staticmethod  
          def rc_xy(row, col):  
              """(row, col) -> (x, y)"""  
              return int(Manager.list_x + (col - Manager.col) * Manager.__brick_size), int \  
                  (Manager.list_y + (row - Manager.row) * Manager.__brick_size)  
        
          @staticmethod  
          def xy_rc(x, y):  
              """(x, y) -> (row, col)"""  
              return int((y - Manager.list_y) / Manager.__brick_size + Manager.row), int \  
                  ((x - Manager.list_x) / Manager.__brick_size + Manager.col)  
        
          @staticmethod  
          def draw_brick(x, y):  
              """Draw a brick at (x, y)."""  
              brick = Element(Element.brick, (x, y))  
              Manager.screen.blit(brick.image, brick.rect)  
        
          def draw_task(self, task_animal_num, which_animal, board_position=(400, 90), animal_position=(430, 35),  
                        txt_position=(455, 60)):  
              """  
              绘制任务板  
              """        txt_size = 24  
              txt_color = (0, 0, 0)  
              Board(Board.task_board, board_position).draw(self.screen)  
              if which_animal == 6:  
                  task_animal = Element(Element.ice, animal_position)  
              else:  
                  task_animal = Element(Element.animals[which_animal], animal_position)  
              task_animal.image = pygame.transform.smoothscale(task_animal.image, (40, 40))  
              task_animal.draw(self.screen)  
              if which_animal == 6:  
                  if task_animal_num - self.ice_num <= 0:  
                      Board(Board.ok, (txt_position[0], txt_position[1] + 15)).draw(self.screen)  
                  else:  
                      self.load_text(str(task_animal_num - self.ice_num), txt_position, txt_size, txt_color)  
              else:  
                  if task_animal_num - self.animal_num[which_animal] <= 0:  
                      Board(Board.ok, (txt_position[0], txt_position[1] + 15)).draw(self.screen)  
                  else:  
                      self.load_text(str(task_animal_num - self.animal_num[which_animal]), txt_position, txt_size, txt_color)  
        
          def draw(self):  
              """绘制背景、动物等元素。"""  
              # 绘制背景  
              self.screen.blit(Manager.__bg, (0, 0))  
              # 显示剩余步数  
              Board(Board.step_board, (0, 142)).draw(self.screen)  
              tens, single = divmod(self.step, 10)  
              if tens == 0:  
                  Board(Board.num_format % single, (790, 110)).draw(self.screen)  
              else:  
                  Board(Board.num_format % tens, (775, 110)).draw(self.screen)  
                  Board(Board.num_format % single, (805, 110)).draw(self.screen)  
              # 显示关卡和暂停按钮  
              Board(Board.level_format % self.level, (30, 105)).draw(self.screen)  
              Element(Element.stop, Element.stop_position).draw(self.screen)  
        
              # 绘制砖块、冰块和动物  
              brick_group = pygame.sprite.Group()  
              animal_group = pygame.sprite.Group()  
              ice_group = pygame.sprite.Group()  
              for i in range(0, 21):  
                  for j in range(0, 21):  
                      x, y = Manager.rc_xy(i, j)  
                      if self.animal[i][j] != -1:  
                          brick_group.add(Element(Element.brick, (x, y)))  
                          animal_group.add(Element(Element.animals[self.animal[i][j]], (x, y)))  
                      if self.ice_list[i][j] != -1:  
                          ice_group.add(Element(Element.ice, (x, y)))  
              brick_group.draw(self.screen)  
              ice_group.draw(self.screen)  
              for animal_list in animal_group:  
                  self.screen.blit(animal_list.image, animal_list.rect)  
              if self.level == 1:  
                  self.draw_task(10, 4)  
              elif self.level == 2:  
                  self.draw_task(21, 1)  
              elif self.level == 3:  
                  self.draw_task(16, 4, (300, 90), (330, 35), (360, 60))  
                  self.draw_task(16, 5, (500, 90), (530, 35), (560, 60))  
              elif self.level == 4:  
                  self.draw_task(18, 5, (300, 90), (330, 35), (360, 60))  
                  self.draw_task(18, 2, (500, 90), (530, 35), (560, 60))  
              elif self.level == 5:  
                  self.draw_task(28, 2, (300, 90), (330, 35), (360, 60))  
                  self.draw_task(28, 0, (500, 90), (530, 35), (560, 60))  
              elif self.level == 6:  
                  self.draw_task(70, 4)  
              elif self.level == 7:  
                  self.draw_task(36, 1)  
                  self.draw_task(36, 2, (300, 90), (330, 35), (360, 60))  
                  self.draw_task(36, 0, (500, 90), (530, 35), (560, 60))  
              elif self.level == 8:  
                  self.draw_task(15, 6)  
              elif self.level == 9:  
                  self.draw_task(49, 6)  
              else:  
                  self.draw_task(39, 6)  
        
              # 显示选择的动物  
              if self.selected != [-1, -1]:  
                  frame_sprite = Element(Element.frame, Manager.rc_xy(self.selected[0], self.selected[1]))  
                  self.screen.blit(frame_sprite.image, frame_sprite.rect)  
        
              # 显示得分  
              self.load_text('得分:' + str(self.score), (300, 550), 30)  
              pygame.draw.rect(self.screen, (50, 150, 50, 180), Rect(300, 570, self.score * 2, 25))  
              pygame.draw.rect(self.screen, (100, 200, 100, 180), Rect(300, 570, 200, 25), 2)  
              return animal_group  
        
          def mouse_image(self):  
              # 加载鼠标图片  
              mouse_cursor = pygame.image.load(os.path.join(img_basic, 'mouse.png')).convert_alpha()  
              mouse_x, mouse_y = pygame.mouse.get_pos()  
              # 计算鼠标左上角位置  
              mouse_x -= mouse_cursor.get_width() / 2  
              mouse_y -= mouse_cursor.get_height() / 2  
              # 绘制鼠标图片  
              self.screen.blit(mouse_cursor, (mouse_x, mouse_y))  
        
          def mouse_select(self, mousex, mousey):  
              if self.type == 1:  # 已通关  
                  if Board.button_position[0][0] < mousex < Board.button_position[0][0] + 100 \  
                          and Board.button_position[0][1] - 50 < mousey < Board.button_position[0][  
                      1]:  # 点击重玩按钮  
                      if self.energy_num < 5:  
                          self.level = 0  
                      self.reset_mode = True  
                  elif Board.button_position[1][0] < mousex < Board.button_position[1][0] + 100 \  
                          and Board.button_position[1][1] - 50 < mousey < Board.button_position[1][  
                      1]:  # 点击下一关按钮  
                      if self.level < 10:  
                          if self.energy_num < 5:  
                              self.level = 0  
                          else:  
                              self.level += 1  
                          self.reset_mode = True  
                  elif 610 < mousex < 610 + 55 and 205 - 55 < mousey < 205:  # x  
                      self.level = 0  
                      self.reset_mode = True  
        
              elif self.type == -1:  # 未通过  
                  if Board.button_position[1][0] < mousex < Board.button_position[1][0] + 100 \  
                          and Board.button_position[1][1] - 50 < mousey < Board.button_position[1][1]:  # 点击重玩按钮  
                      if self.energy_num < 5:  
                          self.level = 0  
                      self.reset_mode = True  
                  elif Board.button_position[0][0] < mousex < Board.button_position[0][0] + 100 \  
                          and Board.button_position[0][1] - 50 < mousey < Board.button_position[0][  
                      1]:  # 点击再来5步按钮  
                      if self.money < 5:  
                          self.level = 0  
                      else:  
                          self.money -= 5  
                          self.step += 5  
                          self.type = 0  # 正在游戏  
                          self.fail_board = Board(Board.fail, [200, 0])  
                  elif 610 < mousex < 610 + 55 and 205 - 55 < mousey < 205:  
                      self.level = 0  
                      self.reset_mode = True  
        
              elif self.type == 0:  # 游戏中  
                  if self.list_x < mousex < self.list_x + Manager.__brick_size * self.width \  
                          and self.list_y < mousey < self.list_y + Manager.__brick_size * self.height:  
                      mouse_selected = Manager.xy_rc(mousex, mousey)  
                      if self.animal[mouse_selected[0]][mouse_selected[1]] != -1:  
                          play_sound(Sounds.CLICK)  
                          self.selected = mouse_selected  
                          if (self.last_sel[0] == self.selected[0]  
                              and abs(self.last_sel[1] - self.selected[1]) == 1) \  
                                  or (self.last_sel[1] == self.selected[1]  
                                      and abs(self.last_sel[0] - self.selected[0]) == 1):  
                              self.swap_sign = 1  # 有效移动，交换  
                  elif Element.stop_position[0] < mousex < Element.stop_position[0] + self.stop_width and \  
                          Element.stop_position[1] < mousey < Element.stop_position[1] + self.stop_width:  # 点击退出按钮  
                      play_sound(Sounds.CLICK_BUTTON)  
                      self.level = 0  
                      self.reset_mode = True  
                  else:  
                      self.selected = [-1, -1]  
        
          def swap(self, group):  
              """在棋盘上交换两个选定的动物。"""  
              last_sprite = None  
              selected_sprite = None  
              if self.swap_sign == -1:  # 尚未交换  
                  self.last_sel = self.selected  
              if self.swap_sign == 1:  
                  last_x, last_y = Manager.rc_xy(self.last_sel[0], self.last_sel[1])  
                  sel_x, sel_y = Manager.rc_xy(self.selected[0], self.selected[1])  
                  if self.last_sel[0] == self.selected[0]:  # 纵向交换  
                      for animal_list in group:  
                          if animal_list.rect.topleft == (last_x, last_y):  
                              last_sprite = animal_list  
                              last_sprite.speed = [self.selected[1] - self.last_sel[1], 0]  
                          elif animal_list.rect.topleft == (sel_x, sel_y):  
                              selected_sprite = animal_list  
                              selected_sprite.speed = [self.last_sel[1] - self.selected[1], 0]  
                  else:  # 横向交换  
                      for animal_list in group:  
                          if animal_list.rect.topleft == (last_x, last_y):  
                              last_sprite = animal_list  
                              last_sprite.speed = [0, self.selected[0] - self.last_sel[0]]  
                          elif animal_list.rect.topleft == (sel_x, sel_y):  
                              selected_sprite = animal_list  
                              selected_sprite.speed = [0, self.last_sel[0] - self.selected[0]]  
                  while last_sprite and last_sprite.speed != [0, 0]:  
                      delay(5)  
                      self.draw_brick(last_x, last_y)  
                      self.draw_brick(sel_x, sel_y)  
                      last_sprite.move(last_sprite.speed)  
                      selected_sprite.move(selected_sprite.speed)  
                      self.screen.blit(last_sprite.image, last_sprite.rect)  
                      self.screen.blit(selected_sprite.image, selected_sprite.rect)  
                      pygame.display.flip()  
        
                  self.swap_values()  
                  if self.eliminate_animals():  
                      self.step -= 1  
                  else:  
                      self.swap_values()  
                  self.value_swapped = False  
                  self.boom_sel = self.selected  
                  self.swap_sign = -1  
                  self.selected = [-1, -1]  
        
          def swap_values(self):  
              """交换值。"""  
              (xl, yl), (xc, yc) = self.last_sel, self.selected  
              self.animal[xl][yl], self.animal[xc][yc] = self.animal[xc][yc], self.animal[xl][yl]  
        
          def load_text(self, text, position, txt_size, txt_color=(255, 255, 255)):  
              """显示给定位置、大小和颜色的文本。"""  
              my_font = pygame.font.SysFont("黑体", txt_size)  
              text_screen = my_font.render(text, True, txt_color)  
              self.screen.blit(text_screen, position)  
        
          def death_map(self):  
              """检查是否没有有效的移动。"""  
              for i in range(self.row, self.row + self.height):  
                  for j in range(self.col, self.col + self.width):  
                      if self.animal[i][j] != -1:  
                          if self.animal[i][j] == self.animal[i][j + 1]:  
                              if (self.animal[i][j] in [self.animal[i - 1][j - 1], self.animal[i + 1][j - 1]] and  
                                  self.animal[i][j - 1] != -1) or (  
                                      self.animal[i][j] in [self.animal[i - 1][j + 2], self.animal[i + 1][j + 2]] and  
                                      self.animal[i][j + 2] != -1):  
                                  self.death_sign = False  
                                  break                    if self.animal[i][j] == self.animal[i + 1][j]:  
                              if (self.animal[i][j] in [self.animal[i - 1][j - 1], self.animal[i - 1][j + 1]] and  
                                  self.animal[i - 1][j] != -1) or (  
                                      self.animal[i][j] in [self.animal[i + 2][j - 1], self.animal[i + 2][j + 1]] and  
                                      self.animal[i + 2][j] != -1):  
                                  self.death_sign = False  
                                  break                    else:  
                              if self.animal[i - 1][j - 1] == self.animal[i][j]:  
                                  if (self.animal[i][j] == self.animal[i - 1][j + 1] and self.animal[i - 1][j] != -1) or (  
                                          self.animal[i][j] == self.animal[i + 1][j - 1] and self.animal[i][j - 1] != -1):  
                                      self.death_sign = False  
                                      break                        if self.animal[i][j] == self.animal[i + 1][j + 1]:  
                                  if (self.animal[i][j] == self.animal[i - 1][j + 1] and self.animal[i][j + 1] != -1) \  
                                          or (self.animal[i][j] == self.animal[i + 1][j - 1] and self.animal[i + 1][j] != -1):  
                                      self.death_sign = False  
                                      break        if self.death_sign:  
                  delay(500)  
                  Element(Element.none_animal, (230, 150)).draw(self.screen)  
                  pygame.display.flip()  
                  delay(500)  
                  temp = [self.step, self.score, self.animal_num, self.ice_num, self.energy_num]  
                  self.reset_mode = True  
                  self.set_level_mode(self.level)  
                  self.step = temp[0]  
                  self.score = temp[1]  
                  self.animal_num = temp[2]  
                  self.ice_num = temp[3]  
                  self.energy_num = temp[4]  
              else:  
                  self.death_sign = True  
        
          def exists_left(self, i, j, num):  
              """检查 (i, j) 左边是否至少有 {num} 个连续的相同动物。"""  
              for t in range(0, num):  
                  if self.animal[i][j] != self.animal[i][j - t] or self.animal[i][j] < 0:  
                      return False  
              return True  
          def exists_right(self, i, j, num):  
              """检查 (i, j) 右边是否至少有 {num} 个连续的相同动物。"""  
              for t in range(0, num):  
                  if self.animal[i][j] != self.animal[i][j + t] or self.animal[i][j] < 0:  
                      return False  
              return True  
          def exists_up(self, i, j, num):  
              """检查 (i, j) 上方是否至少有 {num} 个连续的相同动物。"""  
              for t in range(0, num):  
                  if self.animal[i][j] != self.animal[i - t][j] or self.animal[i][j] < 0:  
                      return False  
              return True  
          def exists_down(self, i, j, num):  
              """检查 (i, j) 下方是否至少有 {num} 个连续的相同动物。"""  
              for t in range(0, num):  
                  if self.animal[i][j] != self.animal[i + t][j] or self.animal[i][j] < 0:  
                      return False  
              return True  
          def change_left(self, i, j, num):  
              """改变动物的左侧。"""  
              self.value_swapped = True  
              self.score += num  
              for k in range(0, int(num)):  
                  self.animal[i][j - k] = -2  
        
          def change_right(self, i, j, num):  
              """改变动物的右侧。"""  
              self.value_swapped = True  
              self.score += num  
              for k in range(0, num):  
                  self.animal[i][j + k] = -2  
        
          def change_up(self, i, j, num):  
              """改变动物上方。"""  
              self.value_swapped = True  
              self.score += num  
              for k in range(0, num):  
                  self.animal[i - k][j] = -2  
        
          def change_down(self, i, j, num):  
              """改变动物下方。"""  
              self.value_swapped = True  
              self.score += num  
              for k in range(0, num):  
                  self.animal[i + k][j] = -2  
        
          def eliminate_animals(self):  
              """消除动物。"""  
              score_level = self.score  
              self.value_swapped = False  
        
              for i in range(self.row, self.row + self.height):  
                  for j in range(self.col, self.col + self.width):  
                      if self.exists_right(i, j, 5):  
                          self.value_swapped = True  
                          if self.exists_down(i, j + 2, 3):  
                              self.animal_num[self.animal[i][j]] += 7  
                              Sounds.eliminate(5)  # 消除音效 5                        self.change_right(i, j, 5)  
                              self.change_down(i, j + 2, 3)  
                          else:  
                              self.animal_num[self.animal[i][j]] += 5  
                              Sounds.eliminate(3)  # 消除音效 3                        self.change_right(i, j, 5)  
                      elif self.exists_right(i, j, 4):  
                          self.value_swapped = True  
                          if self.exists_down(i, j + 1, 3):  
                              self.animal_num[self.animal[i][j]] += 6  
                              Sounds.eliminate(4)  # 消除音效 4                        self.change_right(i, j, 4)  
                              self.change_down(i, j + 1, 3)  
                          elif self.exists_down(i, j + 2, 3):  
                              self.animal_num[self.animal[i][j]] += 6  
                              Sounds.eliminate(4)  # 消除音效 4                        self.change_right(i, j, 4)  
                              self.change_down(i, j + 2, 3)  
                          else:  
                              self.animal_num[self.animal[i][j]] += 4  
                              Sounds.eliminate(2)  # 消除音效 2                        self.change_right(i, j, 4)  
                      elif self.exists_right(i, j, 3):  
                          self.value_swapped = True  
                          if self.exists_down(i, j, 3):  
                              self.animal_num[self.animal[i][j]] += 5  
                              Sounds.eliminate(3)  # 消除音效 3                        self.change_right(i, j, 3)  
                              self.change_down(i, j, 3)  
                          elif self.exists_down(i, j + 1, 3):  
                              self.animal_num[self.animal[i][j]] += 5  
                              Sounds.eliminate(3)  # 消除音效 3                        self.change_right(i, j, 3)  
                              self.change_down(i, j + 1, 3)  
                          elif self.exists_down(i, j + 2, 3):  
                              self.animal_num[self.animal[i][j]] += 5  
                              Sounds.eliminate(3)  # 消除音效 3                        self.change_right(i, j, 3)  
                              self.change_down(i, j + 2, 3)  
                          else:  
                              self.animal_num[self.animal[i][j]] += 3  
                              Sounds.eliminate(1)  # 消除音效 1                        self.change_right(i, j, 3)  
                      elif self.exists_down(i, j, 5):  
                          self.value_swapped = True  
                          if self.exists_right(i + 2, j, 3):  
                              self.animal_num[self.animal[i][j]] += 7  
                              Sounds.eliminate(5)  # 消除音效 5                        self.change_down(i, j, 5)  
                              self.change_right(i + 2, j, 3)  
                          elif self.exists_left(i + 2, j, 3):  
                              self.animal_num[self.animal[i][j]] += 7  
                              Sounds.eliminate(5)  # 消除音效 5                        self.change_down(i, j, 5)  
                              self.change_left(i + 2, j, 3)  
                          else:  
                              self.animal_num[self.animal[i][j]] += 5  
                              Sounds.eliminate(3)  # 消除音效 3                        self.change_down(i, j, 5)  
                      elif self.exists_down(i, j, 4):  
                          self.value_swapped = True  
                          if self.exists_left(i + 1, j, 3):  
                              self.animal_num[self.animal[i][j]] += 6  
                              Sounds.eliminate(4)  # 消除音效 4                        self.change_down(i, j, 4)  
                              self.change_left(i + 1, j, 3)  
                          elif self.exists_right(i + 1, j, 3):  
                              self.animal_num[self.animal[i][j]] += 6  
                              Sounds.eliminate(4)  # 消除音效 4                        self.change_down(i, j, 4)  
                              self.change_right(i + 1, j, 3)  
                          elif self.exists_left(i + 2, j, 3):  
                              self.animal_num[self.animal[i][j]] += 6  
                              Sounds.eliminate(4)  # 消除音效 4                        self.change_down(i, j, 4)  
                              self.change_left(i + 2, j, 3)  
                          elif self.exists_right(i + 2, j, 3):  
                              self.animal_num[self.animal[i][j]] += 6  
                              Sounds.eliminate(4)  # 消除音效 4                        self.change_down(i, j, 4)  
                              self.change_right(i + 2, j, 3)  
                          else:  
                              self.animal_num[self.animal[i][j]] += 4  
                              Sounds.eliminate(2)  # 消除音效 2                        self.change_down(i, j, 4)  
                      elif self.exists_down(i, j, 3):  
                          self.value_swapped = True  
                          if self.exists_left(i + 1, j, 3):  
                              self.animal_num[self.animal[i][j]] += 5  
                              Sounds.eliminate(3)  # 消除音效 3                        self.change_down(i, j, 3)  
                              self.change_left(i + 1, j, 3)  
                          elif self.exists_right(i + 1, j, 3):  
                              self.animal_num[self.animal[i][j]] += 5  
                              Sounds.eliminate(3)  # 消除音效 3                        self.change_down(i, j, 3)  
                              self.change_right(i + 1, j, 3)  
                          elif self.exists_left(i + 2, j, 3):  
                              self.animal_num[self.animal[i][j]] += 5  
                              Sounds.eliminate(3)  # 消除音效 3                        self.change_down(i, j, 3)  
                              self.change_left(i + 2, j, 3)  
                          elif self.exists_right(i + 2, j, 3):  
                              self.animal_num[self.animal[i][j]] += 5  
                              Sounds.eliminate(3)  # 消除音效 3                        self.change_down(i, j, 3)  
                              self.change_right(i + 2, j, 3)  
                          elif self.exists_left(i + 2, j, 2) and self.exists_right(i + 2, j, 2):  
                              self.animal_num[self.animal[i][j]] += 5  
                              Sounds.eliminate(3)  # 消除音效 3                        self.change_down(i, j, 3)  
                              self.change_left(i + 2, j, 2)  
                              self.change_right(i + 2, j, 2)  
                          elif self.exists_left(i + 2, j, 2) and self.exists_right(i + 2, j, 3):  
                              self.animal_num[self.animal[i][j]] += 6  
                              Sounds.eliminate(4)  # 消除音效 4                        self.change_down(i, j, 3)  
                              self.change_left(i + 2, j, 2)  
                              self.change_right(i + 2, j, 3)  
                          elif self.exists_left(i + 2, j, 3) and self.exists_right(i + 2, j, 2):  
                              self.animal_num[self.animal[i][j]] += 6  
                              Sounds.eliminate(4)  # 消除音效 4                        self.change_down(i, j, 3)  
                              self.change_left(i + 2, j, 3)  
                              self.change_right(i + 2, j, 2)  
                          elif self.exists_left(i + 2, j, 3) and self.exists_right(i + 2, j, 3):  
                              self.animal_num[self.animal[i][j]] += 7  
                              Sounds.eliminate(5)  # 消除音效 5                        self.change_down(i, j, 3)  
                              self.change_left(i + 2, j, 3)  
                              self.change_right(i + 2, j, 3)  
                          else:  
                              self.animal_num[self.animal[i][j]] += 3  
                              Sounds.eliminate(1)  # 消除音效 1                        self.change_down(i, j, 3)  
        
              self.fall_animal()  
              score_level = self.score - score_level  # 计分级别  
        
              # 显示 & 朗读：好，棒，了不起，极好，令人难以置信  
              if score_level < 5:  
                  return self.value_swapped  
              if score_level < 8:  # 5 好  
                  Sounds.score_level(0)  
                  Element(Element.score_level[0], (350, 250)).draw(self.screen)  
                  pygame.display.flip()  
                  delay(500)  
              elif score_level < 10:  # 8 棒  
                  Sounds.score_level(1)  
                  Element(Element.score_level[1], (350, 250)).draw(self.screen)  
                  pygame.display.flip()  
                  delay(500)  
              elif score_level < 15:  # 10 了不起  
                  Sounds.score_level(2)  
                  Element(Element.score_level[2], (350, 250)).draw(self.screen)  
                  pygame.display.flip()  
                  delay(500)  
              elif score_level < 20:  # 15 极好  
                  Sounds.score_level(3)  
                  Element(Element.score_level[3], (350, 250)).draw(self.screen)  
                  pygame.display.flip()  
                  delay(500)  
              elif score_level >= 20:  # 20 令人难以置信  
                  Sounds.score_level(4)  
                  Element(Element.score_level[4], (350, 250)).draw(self.screen)  
                  pygame.display.flip()  
                  delay(500)  
        
              return self.value_swapped  # 返回交换值标记  
        
          def fall_animal(self):  
              """动物下落动画。"""  
              clock = pygame.time.Clock()  
              position = []  
              ice_position = []  
        
              # 收集需要下落的动物的位置  
              for i in range(self.row, self.row + self.height):  
                  for j in range(self.col, self.col + self.width):  
                      if self.animal[i][j] == -2:  
                          x, y = self.rc_xy(i, j)  
                          position.append((x, y))  
                          if self.ice_list[i][j] == 1:  
                              ice_position.append((x, y))  
        
              # 下落动画  
              if position:  
                  for index in range(0, 9):  
                      clock.tick(20)  
                      for pos in position:  
                          self.draw_brick(pos[0], pos[1])  
                          if pos in ice_position:  
                              Element(Element.ice_format % index, (pos[0], pos[1])).draw(self.screen)  
                          Element(Element.boom_format % index, (pos[0], pos[1])).draw(self.screen)  
                          pygame.display.flip()  
        
              # 实现下落  
              for i in range(self.row, self.row + self.height):  
                  brick_position = []  
                  fall_animal_list = []  
                  speed = [0, 1]  
        
                  # 收集需要下落的动物的位置信息  
                  for j in range(self.col, self.col + self.width):  
                      if self.animal[i][j] == -2:  
                          x, y = self.rc_xy(i, j)  
                          if self.ice_list[i][j] == 1:  
                              play_sound(Sounds.ICE_BREAKING)  
                              self.ice_num += 1  
                              self.ice_list[i][j] = -1  
        
                          brick_position.append((x, y))  
        
                          # 收集需要下落的动物的信息  
                          for m in range(i, self.row - 1, -1):  
                              if self.animal[m - 1][j] != -1:  
                                  x, y = self.rc_xy(m - 1, j)  
                                  brick_position.append((x, y))  
                                  animal = Element(Element.animals[self.animal[m - 1][j]], (x, y))  
                                  fall_animal_list.append(animal)  
                                  self.animal[m][j] = self.animal[m - 1][j]  
                              else:  
                                  self.animal[m][j] = randint(0, 5)  
                                  break  
        
                  # 动物下落实现  
                  while speed != [0, 0] and fall_animal_list:  
                      for position in brick_position:  
                          self.draw_brick(position[0], position[1])  
                      for animal_sprite in fall_animal_list:  
                          animal_sprite.move(speed)  
                          animal_sprite.draw(self.screen)  
                          speed = animal_sprite.speed  
                      pygame.display.flip()  
        
          def judge_next(self, tp, score):  
              """判断是否达到下一关。"""  
              if tp == 1:  # 通过  
                  self.load_fns_window(score)  
              elif tp == -1:  # 失败  
                  self.load_fail_window()  
        
          def load_fail_window(self):  
              """显示失败界面和按钮。"""  
              sound_sign = 0  
              step_add = Board(Board.step_add, Board.button_position[0])  # 左侧：再来5步  
              retry = Board(Board.replay, Board.button_position[1])  # 右侧：重玩  
              self.screen.blit(self.fail_board.image, self.fail_board.rect)  # 失败界面  
              self.screen.blit(step_add.image, step_add.rect)  
              self.screen.blit(retry.image, retry.rect)  
              while self.fail_board.speed != [0, 0]:  
                  self.draw()  
                  self.screen.blit(self.fail_board.image, self.fail_board.rect)  
                  self.fail_board.move()  
                  pygame.display.flip()  
                  if sound_sign == 0:  
                      play_sound(Sounds.BOARD_SOUND)  
                      sound_sign = 1  
        
          def load_fns_window(self, score):  
              """显示成功界面、分数和按钮。"""  
              sound_sign = 0  
              replay = Board(Board.replay, Board.button_position[0])  # 左侧：重玩  
              self.screen.blit(self.success_board.image, self.success_board.rect)  # 成功界面  
              if self.level < 10:  # 如果不是最后一关  
                  next_level = Board(Board.next, Board.button_position[1])  # 右侧：下一关  
                  self.screen.blit(next_level.image, next_level.rect)  
              self.screen.blit(replay.image, replay.rect)  
              while self.success_board.speed != [0, 0]:  
                  self.draw()  
                  self.screen.blit(self.success_board.image, self.success_board.rect)  
                  self.success_board.move()  
                  pygame.display.flip()  
                  if sound_sign == 0:  
                      play_sound(Sounds.BOARD_SOUND)  
                      sound_sign = 1  
              self.displayStars(score)  # 显示星星  
              # 金币  
              self.load_text(str(self.score * 2), (Board.starts_position[0][0] + 75, Board.starts_position[0][0] + 46), 20,  
                             (0, 0, 0))  
        
          def displayStars(self, score):  
              """根据分数显示星星。"""  
              star1 = Board(Board.stars, Board.starts_position[0])  
              star2 = Board(Board.stars, Board.starts_position[1])  
              star3 = Board(Board.stars, Board.starts_position[2])  
              if 0 <= score < self.min:  
                  self.load_text('1', (Board.starts_position[1][0] + 48, Board.starts_position[1][1] + 35), 20, (0, 0, 0))  
                  self.screen.blit(star1.image, star1.rect)  
              elif self.min <= score <= self.max:  
                  self.load_text('2', (Board.starts_position[1][0] + 48, Board.starts_position[1][1] + 35), 20, (0, 0, 0))  
                  self.screen.blit(star1.image, star1.rect)  
                  self.screen.blit(star2.image, star2.rect)  
              elif score > self.max:  
                  self.load_text('5', (Board.starts_position[1][0] + 48, Board.starts_position[1][1] + 35), 20, (0, 0, 0))  
                  self.screen.blit(star1.image, star1.rect)  
                  self.screen.blit(star2.image, star2.rect)  
                  self.screen.blit(star3.image, star3.rect)  
              pygame.display.flip()  
        
          def set_level_mode(self, level):  
              """设置关卡模式及其步骤。"""  
              self.level = level  
              if self.reset_mode:  # 如果需要重置模式  
                  self.num_sign = True  
                  if level == 1:  
                      self.__init__(7, 7)  
                      self.animal[7][9] = self.animal[7][10] = self.animal[7][11] = self.animal[8][10] = self.animal[11][7] = \  
                          self.animal[11][13] = self.animal[12][7] = self.animal[12][8] = self.animal[12][12] = \  
                          self.animal[12][13] = \  
                          self.animal[13][7] = self.animal[13][8] = self.animal[13][9] = self.animal[13][11] = \  
                          self.animal[13][12] = \  
                          self.animal[13][13] = -1  
                      self.init_step = 17  # 初始步骤17  
                  elif level == 2:  
                      self.__init__(4, 8)  
                      self.init_step = 16  # 初始步骤16  
                  elif level == 3:  
                      self.__init__(7, 7)  
                      self.init_step = 18  # 初始步骤18  
                  elif level == 4:  
                      self.__init__(9, 7)  
                      row, col = self.row, self.col  
                      self.animal[row][col] = self.animal[row][col + 7] = self.animal[row][col + 8] = self.animal[row + 1][  
                          col + 8] = \  
                          self.animal[row + 5][col] = self.animal[row + 6][col] = self.animal[row + 6][col + 1] = \  
                          self.animal[row + 6][col + 8] = -1  
                      self.init_step = 20  
                  elif level == 5:  
                      self.__init__(8, 9)  
                      row, col = self.row, self.col  
                      self.animal[row][col + 7] = self.animal[row + 2][col] = self.animal[row + 5][col] = \  
                          self.animal[row + 3][col + 7] = \  
                          self.animal[row + 6][col + 7] = self.animal[row + 8][col] = -1  
                      self.init_step = 20  
                  elif level == 6:  
                      self.__init__(9, 9)  
                      row, col = self.row, self.col  
                      self.animal[row][col] = self.animal[row][col + 8] = self.animal[row + 2][col + 4] = \  
                          self.animal[row + 3][col + 2] = \  
                          self.animal[row + 3][col + 6] = self.animal[row + 8][col] = self.animal[row + 8][col + 8] = -1  
                      for i in range(row + 4, row + 6):  
                          for j in range(col + 3, col + 6):  
                              self.animal[i][j] = -1  
                      self.init_step = 28  
                  elif level == 7:  
                      self.__init__(9, 9)  
                      row, col = self.row, self.col  
                      for i in range(row, row + 9):  
                          self.animal[i][col + 4] = -1  
                      for j in range(col, col + 4):  
                          self.animal[row + 3][j] = -1  
                      for j in range(col + 5, col + 9):  
                          self.animal[row + 5][j] = -1  
                      self.init_step = 25  
                  elif level == 8:  
                      self.__init__(7, 8)  
                      row, col = self.row, self.col  
                      for i in range(row + 2, row + 5):  
                          for j in range(col + 1, col + 6):  
                              self.ice_list[i][j] = 1  
                      self.init_step = 21  
                  elif level == 9:  
                      self.__init__(9, 9)  
                      row, col = self.row, self.col  
                      self.animal[row][col + 4] = self.animal[row + 4][col] = self.animal[row + 4][col + 8] = \  
                          self.animal[row + 8][col + 4] = -1  
                      for i in range(row + 1, row + 8):  
                          for j in range(col + 1, col + 8):  
                              self.ice_list[i][j] = 1  
                      self.init_step = 35  
                  else:  
                      self.__init__(9, 9)  
                      row, col = self.row, self.col  
                      for i in range(row, row + 2):  
                          for j in range(col, col + 9):  
                              self.animal[i][j] = -1  
                      self.animal[row][col + 4] = randint(0, 5)  
                      self.animal[row + 1][col + 2] = randint(0, 5)  
                      self.animal[row + 1][col + 4] = randint(0, 5)  
                      self.animal[row + 1][col + 6] = randint(0, 5)  
                      self.animal[row + 2][col + 1] = self.animal[row + 3][col + 1] = self.animal[row + 2][col + 3] = \  
                          self.animal[row + 3][col + 3] = \  
                          self.animal[row + 2][col + 5] = self.animal[row + 3][col + 5] = self.animal[row + 2][col + 7] = \  
                          self.animal[row + 3][col + 7] = self.animal[row + 8][col] = self.animal[row + 8][col + 8] = -1  
                      for i in range(row + 4, row + 8):  
                          for j in range(col, col + 9):  
                              self.ice_list[i][j] = 1  
                      self.ice_list[row + 2][col + 4] = self.ice_list[row + 3][col + 2] = self.ice_list[row + 3][col + 4] = \  
                          self.ice_list[row + 3][col + 6] = 1  
                      self.init_step = 40  
                  self.type = 0  
                  self.energy_num -= 5  
                  self.success_board = Board(Board.success, [200, 0])  # 成功的面板  
                  self.fail_board = Board(Board.fail, [200, 0])  # 失败的面板  
                  self.step = self.init_step  
                  self.score = 0  
                  self.animal_num = [0, 0, 0, 0, 0, 0]  
                  self.ice_num = 0  
                  self.reset_mode = False  
        
          def num_add(self):  
              """增加得分"""  
              if self.num_sign:  
                  self.money += self.score * 2  
                  if self.score < self.min:  
                      self.energy_num += 1  
                  elif self.score < self.max:  
                      self.energy_num += 2  
                  else:  
                      self.energy_num += 5  
                  self.num_sign = False  
        
          def judge_level(self):  
              """检查关卡是否通过"""  
              if self.step <= 0:  
                  self.type = -1  # 游戏结束  
              if self.level == 1:  
                  if self.animal_num[4] >= 10:  # L1: 10 只青蛙  
                      self.type = 1  # 通过第一关  
                      self.num_add()  
              elif self.level == 2:  
                  if self.animal_num[1] >= 21:  # L2: 21 只熊  
                      self.type = 1  # 通过第二关  
                      self.num_add()  
              elif self.level == 3:  
                  if self.animal_num[4] >= 16 and self.animal_num[5] >= 16:  # L3: 16 只青蛙和 16 头牛  
                      self.type = 1  # 通过第三关  
                      self.num_add()  
              elif self.level == 4:  
                  if self.animal_num[5] >= 18 and self.animal_num[2] >= 18:  # L4: 18 头牛和 18 只小鸡  
                      self.type = 1  # 通过第四关  
                      self.num_add()  
              elif self.level == 5:  
                  if self.animal_num[2] >= 28 and self.animal_num[0] >= 28:  # L5: 28 只小鸡和 28 只狐狸  
                      self.type = 1  # 通过第五关  
                      self.num_add()  
              elif self.level == 6:  
                  if self.animal_num[4] >= 70:  # L6: 70 只青蛙  
                      self.type = 1  # 通过第六关  
                      self.num_add()  
              elif self.level == 7:  
                  if self.animal_num[2] >= 36 and self.animal_num[1] >= 36 \  
                          and self.animal_num[0] >= 36:  # L7: 36 只小鸡、36 只熊和 36 只狐狸  
                      self.type = 1  # 通过第七关  
                      self.num_add()  
              elif self.level == 8:  
                  if self.ice_num >= 15:  # L8: 15 冰块  
                      self.type = 1  # 通过第八关  
                      self.num_add()  
              elif self.level == 9:  
                  if self.ice_num >= 49:  # L9: 49 冰块  
                      self.type = 1  # 通过第九关  
                      self.num_add()  
              else:  
                  if self.ice_num >= 39:  # L10: 39 冰块  
                      self.type = 1  # 通过第十关  
                      self.num_add()  
        
              self.judge_next(self.type, self.score)
      

      level_tree.py

      import pygame  
      from pygame import DOUBLEBUF  
      from pygame.time import delay  
        
      from dissipate.sounds import play_sound, Sounds  # 导入声音播放功能和声音资源  
      from dissipate.sprites import Tree  # 导入关卡树的类  
        
        
      class LevelTreeManager:  
          """  
          关卡树管理器类，用于管理关卡树及其相关功能。  
          """    __screen_size = (900, 600)  # 屏幕尺寸  
          screen = pygame.display.set_mode(__screen_size, DOUBLEBUF, 32)  # 设置屏幕显示模式  
          fruit_list = []  # 用于存储水果对象的列表  
          fruit_image = pygame.image.load(Tree.fruit).convert_alpha()  # 加载水果图片  
          fruit_width = fruit_image.get_width()  # 获取水果图片宽度  
          fruit_height = fruit_image.get_height()  # 获取水果图片高度  
          type = 0  # 场景类型，0 表示关卡树场景，1 表示能量场景  
          energy_full = False  # 能量已满标志  
          money_empty = False  # 金钱不足标志  
        
          def display_text(self, text, position, txt_size=25, txt_color=(255, 255, 255)):  
              """  
              显示指定的文本内容。  
              参数：  
              text: 要显示的文本  
              position: 文本位置  
              txt_size: 文本大小  
              txt_color: 文本颜色  
              """        my_font = pygame.font.SysFont(None, txt_size)  # 创建字体对象  
              text_screen = my_font.render(text, True, txt_color)  # 渲染文本  
              self.screen.blit(text_screen, position)  # 在屏幕上绘制文本  
        
          def draw_tree(self, energy_num, money_num):  
              """  
              绘制游戏中的关卡树和相关资源。  
              参数：  
              energy_num: 当前能量值  
              money_num: 当前金钱数量  
              """        Tree(Tree.tree, (0, 600)).draw(self.screen)  # 绘制关卡树  
              Tree(Tree.energy_num, Tree.energy_num_position).draw(self.screen)  # 绘制能量数  
              if energy_num > 30:  
                  self.display_text(str(30) + '/30', (22, 55), 21)  # 显示最大能量值  
              else:  
                  self.display_text(str(energy_num) + '/30', (22, 55), 21)  # 显示当前能量值  
              Tree(Tree.money, (15, 135)).draw(self.screen)  # 绘制金钱  
              self.display_text(str(money_num), (32, 124), 21)  # 显示当前金钱数量  
              for i in range(0, 10):  # 绘制水果  
                  Tree(Tree.fruit, Tree.position[i]).draw(self.screen)  
                  self.display_text(str(i + 1), (Tree.position[i][0] + 15, Tree.position[i][1] - 47))  
              if self.type == 1:  
                  Tree(Tree.energy_buy, Tree.energy_buy_position).draw(self.screen)  # 绘制购买能量按钮  
                  if self.energy_full:  
                      self.display_text('energy is full!', (430, 310), 30, (255, 0, 0))  # 显示能量已满提示  
                      pygame.display.flip()  # 更新屏幕显示  
                      delay(500)  # 延迟500毫秒  
                      self.energy_full = False  # 重置能量已满标志  
                  if self.money_empty:  
                      self.display_text('money is not enough!', (410, 310), 30, (255, 0, 0))  # 显示金钱不足提示  
                      pygame.display.flip()  # 更新屏幕显示  
                      delay(500)  # 延迟500毫秒  
                      self.money_empty = False  # 重置金钱不足标志  
        
          def mouse_select(self, mgr, mouse_x, mouse_y, level, energy_num, money_num):  
              """  
              处理鼠标事件。  
              参数：  
              mgr: 管理器对象  
              mouse_x: 鼠标x坐标  
              mouse_y: 鼠标y坐标  
              level: 当前等级  
              energy_num: 当前能量值  
              money_num: 当前金钱数量  
              """        if self.type == 0:  # 关卡树场景  
                  for i in range(0, 10):  
                      if Tree.position[i][0] < mouse_x < Tree.position[i][0] + self.fruit_width \  
                              and Tree.position[i][1] - self.fruit_height < mouse_y < Tree.position[i][1]:  
                          if energy_num <= 0:  
                              self.type = 1  # 切换到能量场景  
                          else:  
                              level = i + 1  # 更新等级  
                  if Tree.energy_num_position[0] < mouse_x < Tree.energy_num_position[0] + 60 \  
                          and Tree.energy_num_position[1] - 60 < mouse_y < Tree.energy_num_position[1]:  # 点击能量图标  
                      play_sound(Sounds.CLICK)  # 播放点击音效  
                      self.type = 1  # 切换到能量场景  
              else:  # 能量场景  
                  if 408 < mouse_x < 600 and 263 < mouse_y < 313:  # 点击“购买能量”按钮  
                      play_sound(Sounds.CLICK_BUTTON)  # 播放点击按钮音效  
                      if money_num < 50:  
                          self.money_empty = True  # 金钱不足标志设为真  
                      if energy_num >= 30:  
                          self.energy_full = True  # 能量已满标志设为真  
                      elif energy_num < 30 and money_num >= 50:  
                          energy_num += 5  # 增加能量  
                          money_num -= 50  # 减少金钱  
                  elif 619 < mouse_x < 638 and 158 < mouse_y < 177:  # 点击“X”按钮  
                      self.type = 0  # 切换回关卡树场景  
              mgr.level, mgr.energy_num, mgr.money = level, energy_num, money_num  # 更新管理器对象中的等级、能量和金钱信息
      

      sprites.py

      import os  
      from pygame.sprite import Sprite  
      from pygame.image import load  
        
      from dissipate.img import img_basic, img_energy, img_board, img_text, img_level, img_button, img_animal, img_ice, \  
          img_boom  
        
        
      # 基类,GameSprite类定义了所有游戏精灵的基类，包括加载图像、设置位置和绘制方法。  
      class GameSprite(Sprite):  
          def __init__(self, icon, position):  
              # 初始化GameSprite类，继承自pygame的Sprite类。  
              super().__init__()  
              # 加载图像并转换为具有透明通道的格式。  
              self.image = load(icon).convert_alpha()  
              # 获取图像的矩形区域。  
              self.rect = self.image.get_rect()  
              # 设置精灵的位置。  
              self.rect.topleft = position  
              self.rect.bottomleft = position  
        
          def draw(self, screen):  
              # 将精灵绘制到屏幕上。  
              screen.blit(self.image, self.rect)  
        
        
      class Tree(GameSprite):  
          """  
          关卡树类，显示关卡树和相关资源。  
          """    # 树、果实、能量数字、金钱和购买能量按钮的图像路径。  
          tree = os.path.join(img_basic, 'tree.png')  
          fruit = os.path.join(img_basic, 'fruit.png')  
          energy_num = os.path.join(img_energy, 'num.png')  
          money = os.path.join(img_basic, 'money.png')  
          energy_buy = os.path.join(img_energy, 'buy.png')  
        
          # 树、果实、能量数字、购买能量按钮的位置定义。  
          x, y = 340, 510  
          h = 90  
          position = (  
              [x, y],  
              [x + 50, y - 25],  
              [x + 105, y - 45],  
              [x - 5, y - h - 5],  
              [x + 55, y - 25 - h + 10],  
              [x + 105, y - 45 - h],  
              [x, y - h * 2],  
              [x + 50 + 10, y - 25 - h * 2 - 5],  
              [x + 105 + 25, y - 45 - h * 2 - 14],  
              [x + 30, y - h * 3 - 30]  
          )  # 果实位置  
          energy_num_position = (15, 70)  # 能量位置  
          energy_buy_position = (250, 400)  # 购买能量位置  
        
          def __init__(self, icon, position):  
              """  
              初始化树对象  
              """        # 重写GameSprite的构造函数，用于初始化树对象。  
              super().__init__(icon, position)  
              self.image = load(icon).convert_alpha()  
              self.rect = self.image.get_rect()  
              self.rect.bottomleft = position  
        
        
      class Board(GameSprite):  
          """  
          游戏面板类，显示游戏面板和相关资源。  
          Board类继承自GameSprite类，用于创建和显示游戏板的精灵，并包含移动逻辑。  
          """    # 游戏板、数字格式、任务板、成功、失败、下一步、重玩、星星、金钱的图像路径。  
          step_board = os.path.join(img_board, 'step.png')  
          num_format = os.path.join(img_text, '%d.png')  
          task_board = os.path.join(img_basic, 'task.png')  
          ok = os.path.join(img_basic, 'ok.png')  
          level_format = os.path.join(img_level, '%d.png')  
          success = os.path.join(img_board, 'success.png')  
          fail = os.path.join(img_board, 'fail.png')  
          step_add = os.path.join(img_button, 'step_add.png')  
          next = os.path.join(img_button, 'next.png')  
          replay = os.path.join(img_button, 'replay.png')  
          stars = os.path.join(img_basic, 'star.png')  
          money = os.path.join(img_basic, 'money.png')  
        
          # 按钮和星星的位置定义。  
          button_position = [[300, 465], [500, 465]]  
          starts_position = [[330, 340], [413, 340], [495, 340]]  
        
          def __init__(self, icon, position):  
              """  
              初始化板对象  
              """        super().__init__(icon, position)  
              # 重写GameSprite的构造函数，用于初始化板对象。  
              self.image = load(icon).convert_alpha()  
              self.speed = [0, 44]  # 初始速度  
              self.rect = self.image.get_rect()  
              self.rect.bottomleft = position  
        
          def move(self):  
              """  
              根据速度移动面板  
              """        self.rect = self.rect.move(self.speed)  
              if self.rect.bottom >= 543:  # 到达底部边界  
                  self.speed = [0, -45]  
              if self.speed == [0, -45] and self.rect.bottom <= 450:  # 到达顶部边界  
                  self.speed = [0, 0]  
        
        
      class Element(GameSprite):  
          """  
          Element类继承自GameSprite类，用于创建和显示游戏中元素的精灵，并包含移动逻辑。  
          """    # 动物、冰、砖块、框架、爆炸数字、冰的数字格式、分数等级、无动物、退出的图像路径。  
          animals = (  
              os.path.join(img_animal, 'fox.png'),  
              os.path.join(img_animal, 'bear.png'),  
              os.path.join(img_animal, 'chick.png'),  
              os.path.join(img_animal, 'eagle.png'),  
              os.path.join(img_animal, 'frog.png'),  
              os.path.join(img_animal, 'cow.png')  
          )  
          ice = os.path.join(img_ice, 'normal.png')  
          brick = os.path.join(img_basic, 'brick.png')  
          frame = os.path.join(img_basic, 'frame.png')  
          boom_format = os.path.join(img_boom, '%d.png')  
          ice_format = os.path.join(img_ice, '%d.png')  
        
          # 分数图片  
          score_level = (  
              os.path.join(img_text, 'good.png'),  
              os.path.join(img_text, 'great.png'),  
              os.path.join(img_text, 'amazing.png'),  
              os.path.join(img_basic, 'excellent.png'),  
              os.path.join(img_basic, 'unbelievable.png')  
          )  
          none_animal = os.path.join(img_basic, 'none_animal.png')  
          stop = os.path.join(img_basic, 'exit.png')  
          stop_position = (20, 530)  
        
          def __init__(self, icon, position):  
              """  
              初始化元素对象  
              """        # 重写GameSprite的构造函数，用于初始化元素对象。  
              super().__init__(icon, position)  
              self.image = load(icon).convert_alpha()  
              self.rect = self.image.get_rect()  
              self.rect.topleft = position  
              self.speed = [0, 0]  # 初始速度  
              self.init_position = position  # 初始位置  
        
          def move(self, speed):  
              """  
              以给定速度移动元素  
              """        self.speed = speed  
              self.rect = self.rect.move(self.speed)  
              if self.speed[0] != 0:  # 水平移动  
                  if abs(self.rect.left - self.init_position[0]) == self.rect.width:  
                      self.init_position = self.rect.topleft  
                      self.speed = [0, 0]  
              else:  # 垂直移动  
                  if abs(self.rect.top - self.init_position[1]) == self.rect.height:  
                      self.init_position = self.rect.topleft  
                      self.speed = [0, 0]
      

      sounds.py

      from enum import Enum  
      from pygame.mixer import Sound  
      from dissipate.sound import *  
        
        
      # 声音枚举类，用于管理和播放游戏中的各种声音  
      class Sounds(Enum):  
          GAME_BGM = os.path.join(sound_basic, 'GameSceneBGM.ogg')  # 游戏场景背景音乐  
          WORLD_BGM = os.path.join(sound_basic, 'WorldSceneBGM.ogg')  # 世界场景背景音乐  
          ELIMINATE_FORMAT = os.path.join(sound_eliminate, '%d.ogg')  # 消除音效格式  
          SCORE_LEVEL = (  
              os.path.join(sound_basic, 'good.ogg'),  # 分数等级 "好"  
              os.path.join(sound_basic, 'great.ogg'),  # 分数等级 "很好"  
              os.path.join(sound_basic, 'amazing.ogg'),  # 分数等级 "惊人"  
              os.path.join(sound_basic, 'excellent.ogg'),  # 分数等级 "优秀"  
              os.path.join(sound_basic, 'unbelievable.ogg')  # 分数等级 "难以置信"  
          )  
          CLICK = os.path.join(sound_basic, 'click.bubble.ogg')  # 点击气泡音效  
          BOARD_SOUND = os.path.join(sound_basic, 'board.ogg')  # 板子音效  
          CLICK_BUTTON = os.path.join(sound_basic, 'click_common_button.ogg')  # 点击按钮音效  
          MONEY = os.path.join(sound_basic, 'money.ogg')  # 金钱音效  
          ICE_BREAKING = os.path.join(sound_basic, 'ice_break.ogg')  # 冰块破碎音效  
        
          @staticmethod  
          def eliminate(idx):  
              """播放指定索引的消除音效"""  
              Sound(Sounds.ELIMINATE_FORMAT.value % idx).play()  
        
          @staticmethod  
          def score_level(idx):  
              """播放指定索引的分数等级音效"""  
              Sound(Sounds.SCORE_LEVEL.value[idx]).play()  
        
        
      def play_sound(sound: Enum):  
          """播放指定声音，循环次数为1（即不循环）"""  
          Sound(sound.value).play()
      

      完整代码：https://gitcode.com/stormsha1/games/overview

      ---

      🔥🔥🔥道阻且长,行则将至,让我们一起加油吧！🌙🌙🌙

      💖The End💖点点关注，收藏不迷路💖