当前位置：首页 > news >正文

Python游戏开发引擎设计与实现

news 2025/8/2 5:54:03

引言

在当今游戏开发领域，虽然C++和C#等语言占据主导地位，但Python凭借其简洁的语法、丰富的生态系统和快速的开发周期，在独立游戏开发、原型设计和教育领域展现出独特的优势。本文将深入探讨如何从零开始设计和实现一个功能完整的Python游戏引擎，涵盖架构设计、核心模块实现和性能优化等关键技术。

游戏引擎架构概述

核心设计理念

一个优秀的游戏引擎应该具备以下特征：

模块化设计：各个子系统相对独立，便于维护和扩展
高性能：合理的资源管理和渲染优化
易用性：提供简洁的API接口，降低开发门槛
跨平台：支持多种操作系统和设备

引擎架构层次

┌─────────────────────────────────────┐
│           游戏逻辑层                │
├─────────────────────────────────────┤
│           引擎API层                 │
├─────────────────────────────────────┤
│  渲染系统 │ 音频系统 │ 输入系统     │
├─────────────────────────────────────┤
│  资源管理 │ 场景管理 │ 物理系统     │
├─────────────────────────────────────┤
│           核心系统层                │
├─────────────────────────────────────┤
│         平台抽象层(SDL/OpenGL)      │
└─────────────────────────────────────┘

核心模块设计与实现

1. 引擎核心框架

首先，我们需要建立引擎的核心框架，包括主循环、时间管理和基础组件系统：

import pygame
import time
from abc import ABC, abstractmethod
from typing import Dict, List, Optional
from dataclasses import dataclass
from enum import Enumclass GameState(Enum):RUNNING = "running"PAUSED = "paused"STOPPED = "stopped"@dataclass
class EngineConfig:"""引擎配置类"""window_width: int = 800window_height: int = 600fps: int = 60title: str = "Python Game Engine"fullscreen: bool = Falsevsync: bool = Trueclass GameEngine:"""游戏引擎核心类"""def __init__(self, config: EngineConfig):self.config = configself.state = GameState.STOPPEDself.clock = pygame.time.Clock()self.delta_time = 0.0self.last_time = 0.0# 初始化各个子系统self._init_pygame()self.renderer = Renderer(self)self.input_manager = InputManager(self)self.audio_manager = AudioManager(self)self.scene_manager = SceneManager(self)self.resource_manager = ResourceManager(self)def _init_pygame(self):"""初始化Pygame"""pygame.init()flags = pygame.DOUBLEBUFif self.config.fullscreen:flags |= pygame.FULLSCREENif self.config.vsync:flags |= pygame.HWSURFACEself.screen = pygame.display.set_mode((self.config.window_width, self.config.window_height), flags)pygame.display.set_caption(self.config.title)def run(self):"""主游戏循环"""self.state = GameState.RUNNINGself.last_time = time.time()while self.state == GameState.RUNNING:current_time = time.time()self.delta_time = current_time - self.last_timeself.last_time = current_time# 处理事件self.input_manager.process_events()# 更新游戏逻辑if self.state == GameState.RUNNING:self.scene_manager.update(self.delta_time)# 渲染self.renderer.render()# 控制帧率self.clock.tick(self.config.fps)self.cleanup()def cleanup(self):"""清理资源"""self.audio_manager.cleanup()self.resource_manager.cleanup()pygame.quit()

2. 组件系统(ECS架构)

采用Entity-Component-System架构，提供灵活的游戏对象管理：

from typing import Type, TypeVar, Generic
import uuidT = TypeVar('T')class Component:"""组件基类"""passclass Entity:"""实体类"""def __init__(self):self.id = str(uuid.uuid4())self.components: Dict[Type[Component], Component] = {}self.active = Truedef add_component(self, component: Component) -> 'Entity':"""添加组件"""self.components[type(component)] = componentreturn selfdef get_component(self, component_type: Type[T]) -> Optional[T]:"""获取组件"""return self.components.get(component_type)def has_component(self, component_type: Type[Component]) -> bool:"""检查是否有指定组件"""return component_type in self.componentsdef remove_component(self, component_type: Type[Component]):"""移除组件"""if component_type in self.components:del self.components[component_type]class System(ABC):"""系统基类"""def __init__(self, engine: GameEngine):self.engine = engine@abstractmethoddef update(self, entities: List[Entity], delta_time: float):"""更新系统逻辑"""passdef get_entities_with_components(self, entities: List[Entity], *component_types: Type[Component]) -> List[Entity]:"""获取包含指定组件的实体"""return [entity for entity in entities if all(entity.has_component(comp_type) for comp_type in component_types)]

3. 渲染系统

实现高效的2D渲染系统，支持精灵、动画和特效：

import pygame
from pygame import Surface, Rect
from typing import Tuple, Optional
import mathclass Transform(Component):"""变换组件"""def __init__(self, x: float = 0, y: float = 0, rotation: float = 0, scale_x: float = 1, scale_y: float = 1):self.position = pygame.Vector2(x, y)self.rotation = rotationself.scale = pygame.Vector2(scale_x, scale_y)class Sprite(Component):"""精灵组件"""def __init__(self, texture: Surface, layer: int = 0):self.texture = textureself.layer = layerself.visible = Trueself.color = (255, 255, 255, 255)self.flip_x = Falseself.flip_y = Falseclass Animation(Component):"""动画组件"""def __init__(self, frames: List[Surface], frame_duration: float = 0.1):self.frames = framesself.frame_duration = frame_durationself.current_frame = 0self.elapsed_time = 0.0self.playing = Trueself.loop = Trueclass Renderer:"""渲染器"""def __init__(self, engine: GameEngine):self.engine = engineself.camera_x = 0self.camera_y = 0self.render_layers: Dict[int, List[Entity]] = {}def render(self):"""执行渲染"""# 清屏self.engine.screen.fill((0, 0, 0))# 按层级排序渲染entities = self.engine.scene_manager.get_current_scene().entitiesself._sort_entities_by_layer(entities)for layer in sorted(self.render_layers.keys()):for entity in self.render_layers[layer]:self._render_entity(entity)# 更新显示pygame.display.flip()def _sort_entities_by_layer(self, entities: List[Entity]):"""按渲染层级排序实体"""self.render_layers.clear()for entity in entities:if not entity.active:continuesprite = entity.get_component(Sprite)if sprite and sprite.visible:layer = sprite.layerif layer not in self.render_layers:self.render_layers[layer] = []self.render_layers[layer].append(entity)def _render_entity(self, entity: Entity):"""渲染单个实体"""transform = entity.get_component(Transform)sprite = entity.get_component(Sprite)if not transform or not sprite:return# 获取纹理texture = sprite.texture# 处理动画animation = entity.get_component(Animation)if animation and animation.playing and animation.frames:texture = animation.frames[animation.current_frame]# 应用变换if transform.rotation != 0 or transform.scale != pygame.Vector2(1, 1):texture = self._apply_transform(texture, transform)# 计算屏幕位置screen_x = transform.position.x - self.camera_xscreen_y = transform.position.y - self.camera_y# 渲染到屏幕rect = texture.get_rect()rect.center = (screen_x, screen_y)self.engine.screen.blit(texture, rect)def _apply_transform(self, texture: Surface, transform: Transform) -> Surface:"""应用变换到纹理"""# 缩放if transform.scale != pygame.Vector2(1, 1):new_size = (int(texture.get_width() * transform.scale.x),int(texture.get_height() * transform.scale.y))texture = pygame.transform.scale(texture, new_size)# 旋转if transform.rotation != 0:texture = pygame.transform.rotate(texture, transform.rotation)return texture

4. 输入系统

实现统一的输入处理系统，支持键盘、鼠标和手柄：

from enum import Enum
from typing import Dict, Set, Callable, Anyclass InputType(Enum):KEYBOARD = "keyboard"MOUSE = "mouse"GAMEPAD = "gamepad"class InputState(Enum):PRESSED = "pressed"HELD = "held"RELEASED = "released"class InputManager:"""输入管理器"""def __init__(self, engine: GameEngine):self.engine = engineself.key_states: Dict[int, InputState] = {}self.mouse_states: Dict[int, InputState] = {}self.mouse_position = pygame.Vector2(0, 0)self.input_bindings: Dict[str, List[Tuple[InputType, Any]]] = {}self.action_callbacks: Dict[str, List[Callable]] = {}def process_events(self):"""处理输入事件"""# 更新按键状态self._update_key_states()for event in pygame.event.get():if event.type == pygame.QUIT:self.engine.state = GameState.STOPPEDelif event.type == pygame.KEYDOWN:self.key_states[event.key] = InputState.PRESSEDself._trigger_action_by_key(event.key, InputState.PRESSED)elif event.type == pygame.KEYUP:self.key_states[event.key] = InputState.RELEASEDself._trigger_action_by_key(event.key, InputState.RELEASED)elif event.type == pygame.MOUSEBUTTONDOWN:self.mouse_states[event.button] = InputState.PRESSEDelif event.type == pygame.MOUSEBUTTONUP:self.mouse_states[event.button] = InputState.RELEASEDelif event.type == pygame.MOUSEMOTION:self.mouse_position = pygame.Vector2(event.pos)def bind_action(self, action_name: str, input_type: InputType, key_or_button: Any):"""绑定输入动作"""if action_name not in self.input_bindings:self.input_bindings[action_name] = []self.input_bindings[action_name].append((input_type, key_or_button))def register_action_callback(self, action_name: str, callback: Callable):"""注册动作回调"""if action_name not in self.action_callbacks:self.action_callbacks[action_name] = []self.action_callbacks[action_name].append(callback)def is_key_pressed(self, key: int) -> bool:"""检查按键是否被按下"""return self.key_states.get(key) == InputState.PRESSEDdef is_key_held(self, key: int) -> bool:"""检查按键是否被持续按住"""return self.key_states.get(key) == InputState.HELDdef _update_key_states(self):"""更新按键状态"""keys_to_update = list(self.key_states.keys())for key in keys_to_update:if self.key_states[key] == InputState.PRESSED:self.key_states[key] = InputState.HELDelif self.key_states[key] == InputState.RELEASED:del self.key_states[key]

性能优化策略

1. 对象池模式

class ObjectPool:"""对象池，减少频繁的对象创建和销毁"""def __init__(self, factory_func: Callable, initial_size: int = 10):self.factory_func = factory_funcself.available_objects = []self.used_objects = set()# 预创建对象for _ in range(initial_size):obj = factory_func()self.available_objects.append(obj)def acquire(self):"""获取对象"""if self.available_objects:obj = self.available_objects.pop()else:obj = self.factory_func()self.used_objects.add(obj)return objdef release(self, obj):"""释放对象"""if obj in self.used_objects:self.used_objects.remove(obj)self.available_objects.append(obj)# 重置对象状态if hasattr(obj, 'reset'):obj.reset()

2. 空间分割优化

class QuadTree:"""四叉树，用于空间分割优化碰撞检测"""def __init__(self, bounds: Rect, max_objects: int = 10, max_levels: int = 5, level: int = 0):self.bounds = boundsself.max_objects = max_objectsself.max_levels = max_levelsself.level = levelself.objects = []self.nodes = []def clear(self):"""清空四叉树"""self.objects.clear()for node in self.nodes:node.clear()self.nodes.clear()def split(self):"""分割节点"""sub_width = self.bounds.width // 2sub_height = self.bounds.height // 2x = self.bounds.xy = self.bounds.yself.nodes = [QuadTree(Rect(x + sub_width, y, sub_width, sub_height), self.max_objects, self.max_levels, self.level + 1),QuadTree(Rect(x, y, sub_width, sub_height), self.max_objects, self.max_levels, self.level + 1),QuadTree(Rect(x, y + sub_height, sub_width, sub_height), self.max_objects, self.max_levels, self.level + 1),QuadTree(Rect(x + sub_width, y + sub_height, sub_width, sub_height), self.max_objects, self.max_levels, self.level + 1)]def get_index(self, rect: Rect) -> int:"""获取对象应该插入的象限索引"""index = -1vertical_midpoint = self.bounds.x + self.bounds.width // 2horizontal_midpoint = self.bounds.y + self.bounds.height // 2top_quadrant = rect.y < horizontal_midpoint and rect.y + rect.height < horizontal_midpointbottom_quadrant = rect.y > horizontal_midpointif rect.x < vertical_midpoint and rect.x + rect.width < vertical_midpoint:if top_quadrant:index = 1elif bottom_quadrant:index = 2elif rect.x > vertical_midpoint:if top_quadrant:index = 0elif bottom_quadrant:index = 3return index

音频系统实现

音频管理器

import pygame.mixer
from typing import Dict, Optional
import threadingclass AudioClip:"""音频片段类"""def __init__(self, file_path: str):self.file_path = file_pathself.sound = pygame.mixer.Sound(file_path)self.volume = 1.0def play(self, loops: int = 0) -> pygame.mixer.Channel:"""播放音频"""channel = self.sound.play(loops)if channel:channel.set_volume(self.volume)return channeldef set_volume(self, volume: float):"""设置音量"""self.volume = max(0.0, min(1.0, volume))class AudioManager:"""音频管理器"""def __init__(self, engine: GameEngine):self.engine = engineself.audio_clips: Dict[str, AudioClip] = {}self.music_volume = 1.0self.sfx_volume = 1.0self.current_music = None# 初始化音频系统pygame.mixer.pre_init(frequency=44100, size=-16, channels=2, buffer=512)pygame.mixer.init()def load_audio_clip(self, name: str, file_path: str) -> AudioClip:"""加载音频片段"""clip = AudioClip(file_path)self.audio_clips[name] = clipreturn clipdef play_sfx(self, name: str, volume: float = 1.0, loops: int = 0) -> Optional[pygame.mixer.Channel]:"""播放音效"""if name in self.audio_clips:clip = self.audio_clips[name]clip.set_volume(volume * self.sfx_volume)return clip.play(loops)return Nonedef play_music(self, file_path: str, loops: int = -1, volume: float = 1.0):"""播放背景音乐"""try:pygame.mixer.music.load(file_path)pygame.mixer.music.set_volume(volume * self.music_volume)pygame.mixer.music.play(loops)self.current_music = file_pathexcept pygame.error as e:print(f"无法播放音乐文件 {file_path}: {e}")def stop_music(self):"""停止背景音乐"""pygame.mixer.music.stop()self.current_music = Nonedef set_music_volume(self, volume: float):"""设置音乐音量"""self.music_volume = max(0.0, min(1.0, volume))pygame.mixer.music.set_volume(self.music_volume)def set_sfx_volume(self, volume: float):"""设置音效音量"""self.sfx_volume = max(0.0, min(1.0, volume))def cleanup(self):"""清理音频资源"""pygame.mixer.quit()

物理系统

基础物理组件

import pygame
import math
from typing import List, Tuple, Optionalclass RigidBody(Component):"""刚体组件"""def __init__(self, mass: float = 1.0, drag: float = 0.0):self.mass = massself.velocity = pygame.Vector2(0, 0)self.acceleration = pygame.Vector2(0, 0)self.drag = dragself.gravity_scale = 1.0self.is_kinematic = Falseself.is_static = Falsedef add_force(self, force: pygame.Vector2):"""添加力"""if not self.is_static and not self.is_kinematic:self.acceleration += force / self.massdef add_impulse(self, impulse: pygame.Vector2):"""添加冲量"""if not self.is_static and not self.is_kinematic:self.velocity += impulse / self.massclass Collider(Component):"""碰撞器基类"""def __init__(self, is_trigger: bool = False):self.is_trigger = is_triggerself.bounds = pygame.Rect(0, 0, 0, 0)def update_bounds(self, transform: Transform):"""更新碰撞边界"""passclass BoxCollider(Collider):"""盒形碰撞器"""def __init__(self, width: float, height: float, offset_x: float = 0, offset_y: float = 0, is_trigger: bool = False):super().__init__(is_trigger)self.width = widthself.height = heightself.offset = pygame.Vector2(offset_x, offset_y)def update_bounds(self, transform: Transform):"""更新碰撞边界"""center_x = transform.position.x + self.offset.xcenter_y = transform.position.y + self.offset.yself.bounds = pygame.Rect(center_x - self.width / 2,center_y - self.height / 2,self.width,self.height)class CircleCollider(Collider):"""圆形碰撞器"""def __init__(self, radius: float, offset_x: float = 0, offset_y: float = 0, is_trigger: bool = False):super().__init__(is_trigger)self.radius = radiusself.offset = pygame.Vector2(offset_x, offset_y)def update_bounds(self, transform: Transform):"""更新碰撞边界"""center_x = transform.position.x + self.offset.xcenter_y = transform.position.y + self.offset.yself.bounds = pygame.Rect(center_x - self.radius,center_y - self.radius,self.radius * 2,self.radius * 2)class PhysicsSystem(System):"""物理系统"""def __init__(self, engine: GameEngine, gravity: pygame.Vector2 = pygame.Vector2(0, 980)):super().__init__(engine)self.gravity = gravityself.collision_pairs: List[Tuple[Entity, Entity]] = []def update(self, entities: List[Entity], delta_time: float):"""更新物理系统"""# 更新物理运动self._update_physics(entities, delta_time)# 更新碰撞器边界self._update_colliders(entities)# 碰撞检测self._detect_collisions(entities)# 碰撞响应self._resolve_collisions()def _update_physics(self, entities: List[Entity], delta_time: float):"""更新物理运动"""physics_entities = self.get_entities_with_components(entities, Transform, RigidBody)for entity in physics_entities:transform = entity.get_component(Transform)rigidbody = entity.get_component(RigidBody)if rigidbody.is_static:continue# 应用重力if not rigidbody.is_kinematic:gravity_force = self.gravity * rigidbody.gravity_scale * rigidbody.massrigidbody.add_force(gravity_force)# 应用阻力if rigidbody.drag > 0:drag_force = -rigidbody.velocity * rigidbody.dragrigidbody.add_force(drag_force)# 更新速度rigidbody.velocity += rigidbody.acceleration * delta_time# 更新位置transform.position += rigidbody.velocity * delta_time# 重置加速度rigidbody.acceleration = pygame.Vector2(0, 0)def _update_colliders(self, entities: List[Entity]):"""更新碰撞器边界"""collider_entities = self.get_entities_with_components(entities, Transform, Collider)for entity in collider_entities:transform = entity.get_component(Transform)collider = entity.get_component(Collider)collider.update_bounds(transform)def _detect_collisions(self, entities: List[Entity]):"""碰撞检测"""self.collision_pairs.clear()collider_entities = self.get_entities_with_components(entities, Collider)for i in range(len(collider_entities)):for j in range(i + 1, len(collider_entities)):entity1 = collider_entities[i]entity2 = collider_entities[j]collider1 = entity1.get_component(Collider)collider2 = entity2.get_component(Collider)if self._check_collision(collider1, collider2):self.collision_pairs.append((entity1, entity2))def _check_collision(self, collider1: Collider, collider2: Collider) -> bool:"""检查两个碰撞器是否碰撞"""if isinstance(collider1, BoxCollider) and isinstance(collider2, BoxCollider):return collider1.bounds.colliderect(collider2.bounds)elif isinstance(collider1, CircleCollider) and isinstance(collider2, CircleCollider):distance = collider1.bounds.center - collider2.bounds.centerreturn distance.length() <= (collider1.radius + collider2.radius)else:# 混合碰撞检测（简化版）return collider1.bounds.colliderect(collider2.bounds)def _resolve_collisions(self):"""碰撞响应"""for entity1, entity2 in self.collision_pairs:collider1 = entity1.get_component(Collider)collider2 = entity2.get_component(Collider)# 如果是触发器，只发送事件，不进行物理响应if collider1.is_trigger or collider2.is_trigger:self._send_trigger_event(entity1, entity2)continue# 物理碰撞响应self._resolve_physics_collision(entity1, entity2)def _send_trigger_event(self, entity1: Entity, entity2: Entity):"""发送触发器事件"""# 这里可以实现事件系统来通知碰撞passdef _resolve_physics_collision(self, entity1: Entity, entity2: Entity):"""解决物理碰撞"""transform1 = entity1.get_component(Transform)transform2 = entity2.get_component(Transform)rigidbody1 = entity1.get_component(RigidBody)rigidbody2 = entity2.get_component(RigidBody)if not rigidbody1 or not rigidbody2:return# 简单的弹性碰撞响应if not rigidbody1.is_static and not rigidbody2.is_static:# 计算碰撞法向量collision_normal = (transform2.position - transform1.position).normalize()# 分离重叠的对象overlap = self._calculate_overlap(entity1, entity2)separation = collision_normal * overlap / 2transform1.position -= separationtransform2.position += separation# 计算相对速度relative_velocity = rigidbody2.velocity - rigidbody1.velocityvelocity_along_normal = relative_velocity.dot(collision_normal)# 如果对象正在分离，不需要响应if velocity_along_normal > 0:return# 计算反弹系数（简化为0.8）restitution = 0.8impulse_magnitude = -(1 + restitution) * velocity_along_normalimpulse_magnitude /= (1/rigidbody1.mass + 1/rigidbody2.mass)impulse = collision_normal * impulse_magnituderigidbody1.velocity -= impulse / rigidbody1.massrigidbody2.velocity += impulse / rigidbody2.massdef _calculate_overlap(self, entity1: Entity, entity2: Entity) -> float:"""计算重叠距离"""collider1 = entity1.get_component(Collider)collider2 = entity2.get_component(Collider)# 简化计算，返回边界框重叠rect1 = collider1.boundsrect2 = collider2.boundsoverlap_x = min(rect1.right, rect2.right) - max(rect1.left, rect2.left)overlap_y = min(rect1.bottom, rect2.bottom) - max(rect1.top, rect2.top)return min(overlap_x, overlap_y)

场景管理系统

from typing import Dict, Optional, List
from abc import ABC, abstractmethodclass Scene:"""场景类"""def __init__(self, name: str):self.name = nameself.entities: List[Entity] = []self.systems: List[System] = []self.active = Truedef add_entity(self, entity: Entity) -> Entity:"""添加实体到场景"""self.entities.append(entity)return entitydef remove_entity(self, entity: Entity):"""从场景移除实体"""if entity in self.entities:self.entities.remove(entity)def add_system(self, system: System):"""添加系统到场景"""self.systems.append(system)def update(self, delta_time: float):"""更新场景"""if not self.active:return# 更新所有系统for system in self.systems:system.update(self.entities, delta_time)# 移除非活跃实体self.entities = [entity for entity in self.entities if entity.active]def cleanup(self):"""清理场景资源"""self.entities.clear()self.systems.clear()class SceneManager:"""场景管理器"""def __init__(self, engine: GameEngine):self.engine = engineself.scenes: Dict[str, Scene] = {}self.current_scene: Optional[Scene] = Noneself.scene_transition_callback: Optional[Callable] = Nonedef create_scene(self, name: str) -> Scene:"""创建新场景"""scene = Scene(name)self.scenes[name] = scenereturn scenedef load_scene(self, name: str):"""加载场景"""if name in self.scenes:if self.current_scene:self.current_scene.cleanup()self.current_scene = self.scenes[name]if self.scene_transition_callback:self.scene_transition_callback(name)else:print(f"场景 '{name}' 不存在")def get_current_scene(self) -> Optional[Scene]:"""获取当前场景"""return self.current_scenedef update(self, delta_time: float):"""更新当前场景"""if self.current_scene:self.current_scene.update(delta_time)def set_scene_transition_callback(self, callback: Callable):"""设置场景切换回调"""self.scene_transition_callback = callback

资源管理系统

import pygame
import json
import os
from typing import Dict, Any, Optional, TypeVar, Generic
from abc import ABC, abstractmethodT = TypeVar('T')class Resource(ABC):"""资源基类"""def __init__(self, file_path: str):self.file_path = file_pathself.loaded = False@abstractmethoddef load(self):"""加载资源"""pass@abstractmethoddef unload(self):"""卸载资源"""passclass TextureResource(Resource):"""纹理资源"""def __init__(self, file_path: str):super().__init__(file_path)self.surface: Optional[pygame.Surface] = Nonedef load(self):"""加载纹理"""try:self.surface = pygame.image.load(self.file_path).convert_alpha()self.loaded = Trueexcept pygame.error as e:print(f"无法加载纹理 {self.file_path}: {e}")def unload(self):"""卸载纹理"""self.surface = Noneself.loaded = Falseclass AudioResource(Resource):"""音频资源"""def __init__(self, file_path: str):super().__init__(file_path)self.sound: Optional[pygame.mixer.Sound] = Nonedef load(self):"""加载音频"""try:self.sound = pygame.mixer.Sound(self.file_path)self.loaded = Trueexcept pygame.error as e:print(f"无法加载音频 {self.file_path}: {e}")def unload(self):"""卸载音频"""self.sound = Noneself.loaded = Falseclass DataResource(Resource):"""数据资源（JSON等）"""def __init__(self, file_path: str):super().__init__(file_path)self.data: Optional[Dict[str, Any]] = Nonedef load(self):"""加载数据"""try:with open(self.file_path, 'r', encoding='utf-8') as f:self.data = json.load(f)self.loaded = Trueexcept (IOError, json.JSONDecodeError) as e:print(f"无法加载数据文件 {self.file_path}: {e}")def unload(self):"""卸载数据"""self.data = Noneself.loaded = Falseclass ResourceManager:"""资源管理器"""def __init__(self, engine: GameEngine):self.engine = engineself.resources: Dict[str, Resource] = {}self.resource_cache: Dict[str, Any] = {}self.base_path = ""def set_base_path(self, path: str):"""设置资源基础路径"""self.base_path = pathdef load_texture(self, name: str, file_path: str) -> Optional[pygame.Surface]:"""加载纹理资源"""full_path = os.path.join(self.base_path, file_path)if name in self.resources:resource = self.resources[name]if isinstance(resource, TextureResource) and resource.loaded:return resource.surfaceresource = TextureResource(full_path)resource.load()if resource.loaded:self.resources[name] = resourcereturn resource.surfacereturn Nonedef load_audio(self, name: str, file_path: str) -> Optional[pygame.mixer.Sound]:"""加载音频资源"""full_path = os.path.join(self.base_path, file_path)if name in self.resources:resource = self.resources[name]if isinstance(resource, AudioResource) and resource.loaded:return resource.soundresource = AudioResource(full_path)resource.load()if resource.loaded:self.resources[name] = resourcereturn resource.soundreturn Nonedef load_data(self, name: str, file_path: str) -> Optional[Dict[str, Any]]:"""加载数据资源"""full_path = os.path.join(self.base_path, file_path)if name in self.resources:resource = self.resources[name]if isinstance(resource, DataResource) and resource.loaded:return resource.dataresource = DataResource(full_path)resource.load()if resource.loaded:self.resources[name] = resourcereturn resource.datareturn Nonedef get_resource(self, name: str) -> Optional[Resource]:"""获取资源"""return self.resources.get(name)def unload_resource(self, name: str):"""卸载资源"""if name in self.resources:self.resources[name].unload()del self.resources[name]def cleanup(self):"""清理所有资源"""for resource in self.resources.values():resource.unload()self.resources.clear()self.resource_cache.clear()