💝💝💝欢迎莅临我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。
-
推荐:「stormsha的主页」👈，持续学习，不断总结，共同进步，为了踏实，做好当下事儿~
-
专栏导航
- Python系列: Python面试题合集，剑指大厂
- Git系列: Git操作技巧
- GO系列: 记录博主学习GO语言的笔记，该笔记专栏尽量写的试用所有入门GO语言的初学者
- 数据库系列: 详细总结了常用数据库 mysql 技术点,以及工作中遇到的 mysql 问题等
- 运维系列: 总结好用的命令，高效开发
- 算法与数据结构系列: 总结数据结构和算法,不同类型针对性训练,提升编程思维
非常期待和您一起在这个小小的网络世界里共同探索、学习和成长。💝💝💝 ✨✨ 欢迎订阅本专栏 ✨✨
|-----------------------------|
| 💖The Start💖点点关注，收藏不迷路💖 |📒文章目录
完整代码：https://gitcode.com/stormsha1/games/overview
效果图
项目结构
程序代码
run.py
python
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
python
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
python
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
python
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
python
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💖点点关注，收藏不迷路💖 |