1183 lines
34 KiB
Markdown
1183 lines
34 KiB
Markdown
# 场景管理完整指南
|
||
|
||
场景（Scene）是ECS框架中管理游戏对象和系统的核心容器。框架采用融合设计，既支持传统的单Scene模式（向后兼容），也支持高级的多World/多Scene架构。本指南将详细介绍如何有效地使用场景来构建和管理你的游戏。
|
||
|
||
## 场景基础概念
|
||
|
||
### 什么是场景？
|
||
|
||
场景是一个完整的游戏世界容器，它包含：
|
||
- **实体集合** - 所有游戏对象
|
||
- **系统集合** - 处理游戏逻辑的系统
|
||
- **事件系统** - 场景内的事件通信
|
||
- **查询系统** - 高效的实体查询
|
||
- **性能监控** - 场景级别的性能统计
|
||
|
||
```typescript
|
||
import { Scene, Core } from '@esengine/ecs-framework';
|
||
|
||
// 创建场景
|
||
const gameScene = new Scene();
|
||
|
||
// 设置为当前活动场景（推荐使用setScene方法）
|
||
Core.setScene(gameScene);
|
||
```
|
||
|
||
> **注意**: `Core.scene = ` 设置方式已被标记为废弃，推荐使用 `Core.setScene()` 方法。新方法提供更好的类型安全性和可预测的激活时序。
|
||
|
||
### 架构选择指南
|
||
|
||
ECS框架提供两种使用模式：
|
||
|
||
#### 1. 单Scene模式（默认，向后兼容）
|
||
|
||
```typescript
|
||
// 传统用法，无需任何修改
|
||
const scene = new Scene();
|
||
Core.setScene(scene);
|
||
```
|
||
|
||
**适用场景：**
|
||
- 简单游戏、单机游戏
|
||
- 原型开发、快速验证
|
||
- 学习ECS架构
|
||
- 不需要复杂场景管理的项目
|
||
|
||
#### 2. 多World模式（高级功能）
|
||
|
||
```typescript
|
||
// 启用World管理器
|
||
Core.enableWorldManager();
|
||
const worldManager = Core.getWorldManager();
|
||
|
||
// 创建多个World，每个World可包含多个Scene
|
||
const roomWorld = worldManager.createWorld('Room_001');
|
||
const battleScene = roomWorld.createScene('battle');
|
||
const uiScene = roomWorld.createScene('ui');
|
||
|
||
roomWorld.start();
|
||
roomWorld.setSceneActive('battle', true);
|
||
roomWorld.setSceneActive('ui', true);
|
||
```
|
||
|
||
**适用场景：**
|
||
- 多人游戏服务器（每个房间一个World）
|
||
- 复杂应用架构（需要场景隔离）
|
||
- 需要并发处理多个游戏世界
|
||
- 高级场景管理需求
|
||
|
||
### 场景的生命周期
|
||
|
||
```typescript
|
||
class GameScene extends Scene {
|
||
// 场景开始时调用
|
||
onStart() {
|
||
console.log("场景开始");
|
||
this.initializeScene();
|
||
}
|
||
|
||
// 场景更新时调用（每帧）
|
||
update() {
|
||
super.update(); // 调用父类更新
|
||
|
||
// 自定义更新逻辑
|
||
this.updateGameLogic();
|
||
}
|
||
|
||
// 场景结束时调用
|
||
onDestroy() {
|
||
console.log("场景结束");
|
||
this.cleanup();
|
||
super.onDestroy();
|
||
}
|
||
}
|
||
```
|
||
|
||
## 基础场景操作
|
||
|
||
### 1. 创建和配置场景
|
||
|
||
```typescript
|
||
class MenuScene extends Scene {
|
||
private backgroundMusic: AudioClip;
|
||
|
||
onStart() {
|
||
this.setupUI();
|
||
this.setupSystems();
|
||
this.setupInput();
|
||
this.playBackgroundMusic();
|
||
}
|
||
|
||
private setupUI() {
|
||
// 创建菜单UI实体
|
||
const titleEntity = this.createEntity("Title");
|
||
titleEntity.addComponent(new TextComponent("我的游戏", 48));
|
||
titleEntity.addComponent(new PositionComponent(400, 100));
|
||
|
||
const startButton = this.createEntity("StartButton");
|
||
startButton.addComponent(new ButtonComponent("开始游戏"));
|
||
startButton.addComponent(new PositionComponent(400, 300));
|
||
|
||
const settingsButton = this.createEntity("SettingsButton");
|
||
settingsButton.addComponent(new ButtonComponent("设置"));
|
||
settingsButton.addComponent(new PositionComponent(400, 400));
|
||
|
||
const exitButton = this.createEntity("ExitButton");
|
||
exitButton.addComponent(new ButtonComponent("退出"));
|
||
exitButton.addComponent(new PositionComponent(400, 500));
|
||
}
|
||
|
||
private setupSystems() {
|
||
// 添加UI相关系统
|
||
this.addEntityProcessor(new UIRenderSystem());
|
||
this.addEntityProcessor(new ButtonClickSystem());
|
||
this.addEntityProcessor(new MenuTransitionSystem());
|
||
}
|
||
|
||
private setupInput() {
|
||
// 监听按钮点击事件
|
||
this.eventBus.on('button:clicked', this.onButtonClicked, this);
|
||
}
|
||
|
||
private onButtonClicked(data: { buttonName: string }) {
|
||
switch (data.buttonName) {
|
||
case "开始游戏":
|
||
this.transitionToGame();
|
||
break;
|
||
case "设置":
|
||
this.showSettings();
|
||
break;
|
||
case "退出":
|
||
this.exitGame();
|
||
break;
|
||
}
|
||
}
|
||
|
||
private transitionToGame() {
|
||
// 切换到游戏场景
|
||
const gameScene = new GameScene();
|
||
Core.setScene(gameScene);
|
||
}
|
||
}
|
||
```
|
||
|
||
### 2. 游戏主场景
|
||
|
||
```typescript
|
||
class GameScene extends Scene {
|
||
private player: Entity;
|
||
private enemySpawner: Entity;
|
||
private ui: Entity;
|
||
|
||
onStart() {
|
||
this.setupWorld();
|
||
this.setupPlayer();
|
||
this.setupEnemies();
|
||
this.setupSystems();
|
||
this.setupUI();
|
||
}
|
||
|
||
private setupWorld() {
|
||
// 创建背景
|
||
const background = this.createEntity("Background");
|
||
background.addComponent(new SpriteComponent("background.png"));
|
||
background.addComponent(new PositionComponent(0, 0));
|
||
|
||
// 创建边界
|
||
this.createWorldBounds();
|
||
}
|
||
|
||
private setupPlayer() {
|
||
this.player = this.createEntity("Player");
|
||
this.player.addComponent(new PositionComponent(400, 300));
|
||
this.player.addComponent(new VelocityComponent());
|
||
this.player.addComponent(new HealthComponent(100));
|
||
this.player.addComponent(new SpriteComponent("player.png"));
|
||
this.player.addComponent(new PlayerInputComponent());
|
||
this.player.addComponent(new WeaponComponent());
|
||
this.player.tag = EntityTags.PLAYER;
|
||
}
|
||
|
||
private setupEnemies() {
|
||
this.enemySpawner = this.createEntity("EnemySpawner");
|
||
this.enemySpawner.addComponent(new SpawnerComponent());
|
||
this.enemySpawner.addComponent(new PositionComponent(0, 0));
|
||
}
|
||
|
||
private setupSystems() {
|
||
// 输入系统
|
||
this.addEntityProcessor(new PlayerInputSystem()).updateOrder = 0;
|
||
|
||
// 游戏逻辑系统
|
||
this.addEntityProcessor(new MovementSystem()).updateOrder = 10;
|
||
this.addEntityProcessor(new AISystem()).updateOrder = 15;
|
||
this.addEntityProcessor(new WeaponSystem()).updateOrder = 20;
|
||
this.addEntityProcessor(new CollisionSystem()).updateOrder = 30;
|
||
this.addEntityProcessor(new HealthSystem()).updateOrder = 40;
|
||
|
||
// 生成和清理系统
|
||
this.addEntityProcessor(new EnemySpawnSystem()).updateOrder = 50;
|
||
this.addEntityProcessor(new EntityCleanupSystem()).updateOrder = 60;
|
||
|
||
// 渲染系统
|
||
this.addEntityProcessor(new RenderSystem()).updateOrder = 100;
|
||
this.addEntityProcessor(new UIRenderSystem()).updateOrder = 110;
|
||
|
||
// 特效和音频系统
|
||
this.addEntityProcessor(new ParticleSystem()).updateOrder = 120;
|
||
this.addEntityProcessor(new AudioSystem()).updateOrder = 130;
|
||
}
|
||
|
||
private setupUI() {
|
||
this.ui = this.createEntity("GameUI");
|
||
this.ui.addComponent(new HealthBarComponent());
|
||
this.ui.addComponent(new ScoreDisplayComponent());
|
||
this.ui.addComponent(new AmmoDisplayComponent());
|
||
}
|
||
|
||
private createWorldBounds() {
|
||
// 创建世界边界，防止实体跑出屏幕
|
||
const bounds = [
|
||
{ x: 0, y: 0, width: 10, height: 600 }, // 左边界
|
||
{ x: 790, y: 0, width: 10, height: 600 }, // 右边界
|
||
{ x: 0, y: 0, width: 800, height: 10 }, // 上边界
|
||
{ x: 0, y: 590, width: 800, height: 10 } // 下边界
|
||
];
|
||
|
||
bounds.forEach((bound, index) => {
|
||
const wall = this.createEntity(`Wall_${index}`);
|
||
wall.addComponent(new PositionComponent(bound.x, bound.y));
|
||
wall.addComponent(new ColliderComponent(bound.width, bound.height));
|
||
wall.addComponent(new WallComponent());
|
||
wall.tag = EntityTags.WALL;
|
||
});
|
||
}
|
||
}
|
||
```
|
||
|
||
## World多场景管理
|
||
|
||
### 1. World基础使用
|
||
|
||
对于需要复杂场景管理的项目，可以使用World系统：
|
||
|
||
```typescript
|
||
import { Core, World, Scene, WorldManager, IGlobalSystem } from '@esengine/ecs-framework';
|
||
|
||
// 定义全局系统（跨Scene的业务逻辑）
|
||
class NetworkSyncSystem implements IGlobalSystem {
|
||
public readonly name = 'NetworkSyncSystem';
|
||
|
||
public initialize(): void {
|
||
console.log('网络同步系统初始化');
|
||
}
|
||
|
||
public update(): void {
|
||
// 同步所有Scene的网络状态
|
||
this.syncNetworkData();
|
||
}
|
||
|
||
public reset(): void {
|
||
// 重置网络连接
|
||
}
|
||
|
||
public destroy(): void {
|
||
console.log('网络同步系统销毁');
|
||
}
|
||
|
||
private syncNetworkData(): void {
|
||
// 网络数据同步逻辑
|
||
}
|
||
}
|
||
|
||
class PlayerManagementSystem implements IGlobalSystem {
|
||
public readonly name = 'PlayerManagementSystem';
|
||
|
||
public initialize(): void {
|
||
console.log('玩家管理系统初始化');
|
||
}
|
||
|
||
public update(): void {
|
||
// 管理跨Scene的玩家数据
|
||
this.managePlayerStates();
|
||
}
|
||
|
||
public reset(): void {
|
||
// 重置玩家状态
|
||
}
|
||
|
||
public destroy(): void {
|
||
console.log('玩家管理系统销毁');
|
||
}
|
||
|
||
private managePlayerStates(): void {
|
||
// 玩家状态管理逻辑
|
||
}
|
||
}
|
||
|
||
// 启用World管理功能
|
||
Core.enableWorldManager();
|
||
const worldManager = Core.getWorldManager();
|
||
|
||
// 创建游戏房间World
|
||
const roomWorld = worldManager.createWorld('GameRoom_001', {
|
||
name: 'GameRoom_001',
|
||
maxScenes: 5,
|
||
autoCleanup: true,
|
||
debug: true
|
||
});
|
||
|
||
// 在World中创建多个Scene
|
||
const gameScene = roomWorld.createScene('game', new GameScene());
|
||
const uiScene = roomWorld.createScene('ui', new UIScene());
|
||
const backgroundScene = roomWorld.createScene('background', new BackgroundScene());
|
||
|
||
// 添加全局系统（跨Scene的系统）
|
||
roomWorld.addGlobalSystem(new NetworkSyncSystem());
|
||
roomWorld.addGlobalSystem(new PlayerManagementSystem());
|
||
|
||
// 启动World并激活Scene
|
||
roomWorld.start();
|
||
roomWorld.setSceneActive('game', true);
|
||
roomWorld.setSceneActive('ui', true);
|
||
roomWorld.setSceneActive('background', true);
|
||
```
|
||
|
||
### 2. 多房间游戏服务器示例
|
||
|
||
```typescript
|
||
// 房间管理系统
|
||
class RoomManagementSystem implements IGlobalSystem {
|
||
public readonly name = 'RoomManagementSystem';
|
||
private roomId: string;
|
||
|
||
constructor(roomId: string) {
|
||
this.roomId = roomId;
|
||
}
|
||
|
||
public initialize(): void {
|
||
console.log(`房间管理系统初始化: ${this.roomId}`);
|
||
}
|
||
|
||
public update(): void {
|
||
// 管理房间状态、玩家进出等
|
||
this.manageRoomState();
|
||
}
|
||
|
||
public reset(): void {
|
||
// 重置房间状态
|
||
}
|
||
|
||
public destroy(): void {
|
||
console.log(`房间管理系统销毁: ${this.roomId}`);
|
||
}
|
||
|
||
private manageRoomState(): void {
|
||
// 房间状态管理逻辑
|
||
}
|
||
}
|
||
|
||
// 玩家同步系统
|
||
class PlayerSyncSystem implements IGlobalSystem {
|
||
public readonly name = 'PlayerSyncSystem';
|
||
|
||
public initialize(): void {
|
||
console.log('玩家同步系统初始化');
|
||
}
|
||
|
||
public update(): void {
|
||
// 同步房间内所有玩家的状态
|
||
this.syncPlayerData();
|
||
}
|
||
|
||
public reset(): void {
|
||
// 重置同步状态
|
||
}
|
||
|
||
public destroy(): void {
|
||
console.log('玩家同步系统销毁');
|
||
}
|
||
|
||
private syncPlayerData(): void {
|
||
// 玩家数据同步逻辑
|
||
}
|
||
}
|
||
|
||
class MultiRoomGameServer {
|
||
private worldManager: WorldManager;
|
||
private rooms: Map<string, World> = new Map();
|
||
|
||
constructor() {
|
||
Core.create({ debug: false });
|
||
Core.enableWorldManager();
|
||
this.worldManager = Core.getWorldManager();
|
||
}
|
||
|
||
// 创建游戏房间
|
||
createRoom(roomId: string): World {
|
||
const roomWorld = this.worldManager.createWorld(`Room_${roomId}`, {
|
||
name: `GameRoom_${roomId}`,
|
||
maxScenes: 3,
|
||
autoCleanup: true
|
||
});
|
||
|
||
// 房间内的Scene设置
|
||
const gameScene = roomWorld.createScene('game', new ServerGameScene());
|
||
const lobbyScene = roomWorld.createScene('lobby', new LobbyScene());
|
||
|
||
// 设置房间级的全局系统
|
||
roomWorld.addGlobalSystem(new RoomManagementSystem(roomId));
|
||
roomWorld.addGlobalSystem(new PlayerSyncSystem());
|
||
|
||
// 启动房间
|
||
roomWorld.start();
|
||
roomWorld.setSceneActive('lobby', true); // 默认激活大厅
|
||
|
||
this.rooms.set(roomId, roomWorld);
|
||
console.log(`创建房间: ${roomId}`);
|
||
|
||
return roomWorld;
|
||
}
|
||
|
||
// 开始游戏
|
||
startGame(roomId: string): boolean {
|
||
const roomWorld = this.rooms.get(roomId);
|
||
if (!roomWorld) return false;
|
||
|
||
// 停用大厅，激活游戏Scene
|
||
roomWorld.setSceneActive('lobby', false);
|
||
roomWorld.setSceneActive('game', true);
|
||
|
||
console.log(`房间 ${roomId} 开始游戏`);
|
||
return true;
|
||
}
|
||
|
||
// 销毁房间
|
||
destroyRoom(roomId: string): boolean {
|
||
const roomWorld = this.rooms.get(roomId);
|
||
if (!roomWorld) return false;
|
||
|
||
roomWorld.destroy();
|
||
this.rooms.delete(roomId);
|
||
console.log(`销毁房间: ${roomId}`);
|
||
return true;
|
||
}
|
||
|
||
// 获取服务器状态
|
||
getServerStats() {
|
||
return {
|
||
totalRooms: this.rooms.size,
|
||
activeWorlds: this.worldManager.getActiveWorlds().length,
|
||
rooms: Array.from(this.rooms.keys()).map(roomId => ({
|
||
roomId,
|
||
world: this.rooms.get(roomId)?.getStatus()
|
||
}))
|
||
};
|
||
}
|
||
|
||
// 游戏循环
|
||
start(): void {
|
||
const gameLoop = () => {
|
||
const deltaTime = 1000 / 60; // 60 TPS
|
||
Core.update(deltaTime / 1000);
|
||
setTimeout(gameLoop, deltaTime);
|
||
};
|
||
gameLoop();
|
||
}
|
||
}
|
||
|
||
// 使用示例
|
||
const gameServer = new MultiRoomGameServer();
|
||
gameServer.start();
|
||
|
||
// 创建房间
|
||
const room1 = gameServer.createRoom('room_001');
|
||
const room2 = gameServer.createRoom('room_002');
|
||
|
||
// 开始游戏
|
||
setTimeout(() => {
|
||
gameServer.startGame('room_001');
|
||
}, 5000);
|
||
|
||
console.log('服务器状态:', gameServer.getServerStats());
|
||
```
|
||
|
||
### 3. 客户端多Scene管理示例
|
||
|
||
```typescript
|
||
class GameClient {
|
||
private worldManager: WorldManager;
|
||
private mainWorld: World;
|
||
|
||
constructor() {
|
||
Core.create({ debug: true });
|
||
Core.enableWorldManager();
|
||
this.worldManager = Core.getWorldManager();
|
||
|
||
this.setupGameWorld();
|
||
}
|
||
|
||
private setupGameWorld(): void {
|
||
// 创建主游戏世界
|
||
this.mainWorld = this.worldManager.createWorld('MainWorld', {
|
||
name: 'ClientWorld',
|
||
maxScenes: 10,
|
||
autoCleanup: false // 客户端通常不需要自动清理
|
||
});
|
||
|
||
// 创建不同层级的Scene
|
||
this.createGameplayScenes();
|
||
this.createUIScenes();
|
||
this.createEffectScenes();
|
||
|
||
// 启动世界
|
||
this.mainWorld.start();
|
||
this.activateDefaultScenes();
|
||
}
|
||
|
||
private createGameplayScenes(): void {
|
||
// 游戏主场景
|
||
const gameScene = this.mainWorld.createScene('gameplay', new GameplayScene());
|
||
|
||
// 背景场景
|
||
const backgroundScene = this.mainWorld.createScene('background', new BackgroundScene());
|
||
|
||
// 特效场景
|
||
const effectsScene = this.mainWorld.createScene('effects', new EffectsScene());
|
||
}
|
||
|
||
private createUIScenes(): void {
|
||
// 主UI场景
|
||
const mainUIScene = this.mainWorld.createScene('mainUI', new MainUIScene());
|
||
|
||
// 菜单场景
|
||
const menuScene = this.mainWorld.createScene('menu', new MenuScene());
|
||
|
||
// 设置场景
|
||
const settingsScene = this.mainWorld.createScene('settings', new SettingsScene());
|
||
}
|
||
|
||
private createEffectScenes(): void {
|
||
// 粒子效果场景
|
||
const particleScene = this.mainWorld.createScene('particles', new ParticleScene());
|
||
|
||
// 音效场景
|
||
const audioScene = this.mainWorld.createScene('audio', new AudioScene());
|
||
}
|
||
|
||
private activateDefaultScenes(): void {
|
||
// 激活基础Scene
|
||
this.mainWorld.setSceneActive('background', true);
|
||
this.mainWorld.setSceneActive('gameplay', true);
|
||
this.mainWorld.setSceneActive('mainUI', true);
|
||
this.mainWorld.setSceneActive('particles', true);
|
||
this.mainWorld.setSceneActive('audio', true);
|
||
|
||
// 菜单和设置默认不激活
|
||
this.mainWorld.setSceneActive('menu', false);
|
||
this.mainWorld.setSceneActive('settings', false);
|
||
}
|
||
|
||
// 切换到菜单
|
||
showMenu(): void {
|
||
this.mainWorld.setSceneActive('gameplay', false);
|
||
this.mainWorld.setSceneActive('menu', true);
|
||
}
|
||
|
||
// 切换回游戏
|
||
hideMenu(): void {
|
||
this.mainWorld.setSceneActive('menu', false);
|
||
this.mainWorld.setSceneActive('gameplay', true);
|
||
}
|
||
|
||
// 显示设置
|
||
showSettings(): void {
|
||
this.mainWorld.setSceneActive('settings', true);
|
||
}
|
||
|
||
// 隐藏设置
|
||
hideSettings(): void {
|
||
this.mainWorld.setSceneActive('settings', false);
|
||
}
|
||
|
||
// 获取World状态
|
||
getWorldStatus() {
|
||
return this.mainWorld.getStatus();
|
||
}
|
||
}
|
||
|
||
// 使用示例
|
||
const gameClient = new GameClient();
|
||
|
||
// 显示菜单
|
||
gameClient.showMenu();
|
||
|
||
// 5秒后返回游戏
|
||
setTimeout(() => {
|
||
gameClient.hideMenu();
|
||
}, 5000);
|
||
|
||
console.log('客户端World状态:', gameClient.getWorldStatus());
|
||
```
|
||
|
||
## 传统场景切换和管理
|
||
|
||
### 1. 单Scene模式场景管理器
|
||
|
||
> **注意：** 以下的 SceneManager、TransitionManager 等是自定义的场景管理类示例，不是ECS框架提供的内置API。你可以基于这些示例实现自己的场景管理系统。
|
||
|
||
```typescript
|
||
enum SceneType {
|
||
MENU = "menu",
|
||
GAME = "game",
|
||
PAUSE = "pause",
|
||
GAME_OVER = "game_over",
|
||
SETTINGS = "settings"
|
||
}
|
||
|
||
// 自定义场景管理器（示例实现）
|
||
class SceneManager {
|
||
private static instance: SceneManager;
|
||
private currentScene: Scene | null = null;
|
||
private previousScene: Scene | null = null;
|
||
private sceneHistory: Scene[] = [];
|
||
|
||
static getInstance(): SceneManager {
|
||
if (!this.instance) {
|
||
this.instance = new SceneManager();
|
||
}
|
||
return this.instance;
|
||
}
|
||
|
||
switchToScene(sceneType: SceneType, data?: any) {
|
||
// 保存当前场景到历史
|
||
if (this.currentScene) {
|
||
this.previousScene = this.currentScene;
|
||
this.sceneHistory.push(this.currentScene);
|
||
this.currentScene.onDestroy();
|
||
}
|
||
|
||
// 创建新场景
|
||
this.currentScene = this.createScene(sceneType, data);
|
||
Core.setScene(this.currentScene);
|
||
|
||
console.log(`切换到场景: ${sceneType}`);
|
||
}
|
||
|
||
goBack(): boolean {
|
||
if (this.sceneHistory.length > 0) {
|
||
const previousScene = this.sceneHistory.pop()!;
|
||
|
||
if (this.currentScene) {
|
||
this.currentScene.onDestroy();
|
||
}
|
||
|
||
this.currentScene = previousScene;
|
||
Core.setScene(this.currentScene);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
pushScene(sceneType: SceneType, data?: any) {
|
||
// 暂停当前场景，不销毁
|
||
if (this.currentScene) {
|
||
this.previousScene = this.currentScene;
|
||
this.sceneHistory.push(this.currentScene);
|
||
this.pauseScene(this.currentScene);
|
||
}
|
||
|
||
this.currentScene = this.createScene(sceneType, data);
|
||
Core.setScene(this.currentScene);
|
||
}
|
||
|
||
popScene() {
|
||
if (this.sceneHistory.length > 0) {
|
||
if (this.currentScene) {
|
||
this.currentScene.onDestroy();
|
||
}
|
||
|
||
this.currentScene = this.sceneHistory.pop()!;
|
||
this.resumeScene(this.currentScene);
|
||
Core.setScene(this.currentScene);
|
||
}
|
||
}
|
||
|
||
private createScene(sceneType: SceneType, data?: any): Scene {
|
||
switch (sceneType) {
|
||
case SceneType.MENU:
|
||
return new MenuScene();
|
||
case SceneType.GAME:
|
||
return new GameScene(data);
|
||
case SceneType.PAUSE:
|
||
return new PauseScene();
|
||
case SceneType.GAME_OVER:
|
||
return new GameOverScene(data);
|
||
case SceneType.SETTINGS:
|
||
return new SettingsScene();
|
||
default:
|
||
throw new Error(`Unknown scene type: ${sceneType}`);
|
||
}
|
||
}
|
||
|
||
private pauseScene(scene: Scene) {
|
||
// 暂停场景的所有系统
|
||
scene.systems.forEach(system => {
|
||
system.enabled = false;
|
||
});
|
||
}
|
||
|
||
private resumeScene(scene: Scene) {
|
||
// 恢复场景的所有系统
|
||
scene.systems.forEach(system => {
|
||
system.enabled = true;
|
||
});
|
||
}
|
||
}
|
||
|
||
// 使用场景管理器
|
||
const sceneManager = SceneManager.getInstance();
|
||
|
||
// 切换场景
|
||
sceneManager.switchToScene(SceneType.MENU);
|
||
|
||
// 推入场景（用于暂停菜单等）
|
||
sceneManager.pushScene(SceneType.PAUSE);
|
||
|
||
// 弹出场景（返回游戏）
|
||
sceneManager.popScene();
|
||
```
|
||
|
||
### 2. 场景转场效果
|
||
|
||
```typescript
|
||
class TransitionManager {
|
||
private isTransitioning: boolean = false;
|
||
|
||
async fadeTransition(fromScene: Scene, toScene: Scene, duration: number = 1.0) {
|
||
if (this.isTransitioning) return;
|
||
|
||
this.isTransitioning = true;
|
||
|
||
// 创建转场覆盖层
|
||
const overlay = this.createFadeOverlay();
|
||
|
||
// 淡出当前场景
|
||
await this.fadeOut(overlay, duration / 2);
|
||
|
||
// 切换场景
|
||
fromScene.onDestroy();
|
||
Core.setScene(toScene);
|
||
|
||
// 淡入新场景
|
||
await this.fadeIn(overlay, duration / 2);
|
||
|
||
// 清理覆盖层
|
||
overlay.destroy();
|
||
this.isTransitioning = false;
|
||
}
|
||
|
||
async slideTransition(fromScene: Scene, toScene: Scene, direction: 'left' | 'right' | 'up' | 'down') {
|
||
if (this.isTransitioning) return;
|
||
|
||
this.isTransitioning = true;
|
||
|
||
// 实现滑动转场效果
|
||
const slideDistance = this.getSlideDistance(direction);
|
||
|
||
// 移动当前场景
|
||
await this.slideScene(fromScene, slideDistance);
|
||
|
||
// 切换场景
|
||
fromScene.onDestroy();
|
||
Core.setScene(toScene);
|
||
|
||
// 从相反方向滑入新场景
|
||
await this.slideScene(toScene, -slideDistance);
|
||
|
||
this.isTransitioning = false;
|
||
}
|
||
|
||
private createFadeOverlay(): Entity {
|
||
const overlay = Core.scene.createEntity("TransitionOverlay");
|
||
overlay.addComponent(new SpriteComponent("black_pixel.png"));
|
||
overlay.addComponent(new PositionComponent(0, 0));
|
||
|
||
const sprite = overlay.getComponent(SpriteComponent);
|
||
sprite.width = 800;
|
||
sprite.height = 600;
|
||
sprite.alpha = 0;
|
||
|
||
return overlay;
|
||
}
|
||
}
|
||
```
|
||
|
||
## 场景数据管理
|
||
|
||
### 1. 场景间数据传递
|
||
|
||
```typescript
|
||
interface GameData {
|
||
score: number;
|
||
level: number;
|
||
playerName: string;
|
||
difficulty: string;
|
||
}
|
||
|
||
class GameScene extends Scene {
|
||
private gameData: GameData;
|
||
|
||
constructor(data?: GameData) {
|
||
super();
|
||
this.gameData = data || {
|
||
score: 0,
|
||
level: 1,
|
||
playerName: "Player",
|
||
difficulty: "normal"
|
||
};
|
||
}
|
||
|
||
onStart() {
|
||
super.onStart();
|
||
|
||
// 根据传入数据配置场景
|
||
this.setupPlayerWithData();
|
||
this.setupLevelWithDifficulty();
|
||
}
|
||
|
||
private setupPlayerWithData() {
|
||
const player = this.createEntity("Player");
|
||
player.addComponent(new NameComponent(this.gameData.playerName));
|
||
player.addComponent(new ScoreComponent(this.gameData.score));
|
||
// ... 其他组件
|
||
}
|
||
|
||
private setupLevelWithDifficulty() {
|
||
const difficultySettings = {
|
||
easy: { enemySpawnRate: 2.0, enemyHealth: 50 },
|
||
normal: { enemySpawnRate: 1.5, enemyHealth: 75 },
|
||
hard: { enemySpawnRate: 1.0, enemyHealth: 100 }
|
||
};
|
||
|
||
const settings = difficultySettings[this.gameData.difficulty];
|
||
|
||
const spawner = this.createEntity("EnemySpawner");
|
||
const spawnerComp = new SpawnerComponent();
|
||
spawnerComp.spawnInterval = settings.enemySpawnRate;
|
||
spawnerComp.enemyHealth = settings.enemyHealth;
|
||
spawner.addComponent(spawnerComp);
|
||
}
|
||
|
||
// 游戏结束时传递数据到下一个场景
|
||
gameOver() {
|
||
const finalScore = this.getPlayerScore();
|
||
const sceneManager = SceneManager.getInstance();
|
||
|
||
sceneManager.switchToScene(SceneType.GAME_OVER, {
|
||
score: finalScore,
|
||
level: this.gameData.level,
|
||
playerName: this.gameData.playerName
|
||
});
|
||
}
|
||
}
|
||
|
||
class GameOverScene extends Scene {
|
||
constructor(private gameData: GameData) {
|
||
super();
|
||
}
|
||
|
||
onStart() {
|
||
this.displayResults();
|
||
this.setupRestartButton();
|
||
}
|
||
|
||
private displayResults() {
|
||
const scoreText = this.createEntity("ScoreText");
|
||
scoreText.addComponent(new TextComponent(`最终分数: ${this.gameData.score}`));
|
||
scoreText.addComponent(new PositionComponent(400, 200));
|
||
|
||
const levelText = this.createEntity("LevelText");
|
||
levelText.addComponent(new TextComponent(`到达关卡: ${this.gameData.level}`));
|
||
levelText.addComponent(new PositionComponent(400, 250));
|
||
}
|
||
}
|
||
```
|
||
|
||
### 2. 持久化数据管理
|
||
|
||
```typescript
|
||
class SaveManager {
|
||
private static SAVE_KEY = "game_save_data";
|
||
|
||
static saveScene(scene: Scene): void {
|
||
const saveData = {
|
||
playerData: this.extractPlayerData(scene),
|
||
sceneState: this.extractSceneState(scene),
|
||
timestamp: Date.now()
|
||
};
|
||
|
||
localStorage.setItem(this.SAVE_KEY, JSON.stringify(saveData));
|
||
console.log("游戏已保存");
|
||
}
|
||
|
||
static loadScene(): Scene | null {
|
||
const saveDataStr = localStorage.getItem(this.SAVE_KEY);
|
||
if (!saveDataStr) return null;
|
||
|
||
try {
|
||
const saveData = JSON.parse(saveDataStr);
|
||
return this.recreateScene(saveData);
|
||
} catch (error) {
|
||
console.error("读取存档失败:", error);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
private static extractPlayerData(scene: Scene): any {
|
||
const player = scene.findEntitiesWithTag(EntityTags.PLAYER)[0];
|
||
if (!player) return null;
|
||
|
||
return {
|
||
position: player.getComponent(PositionComponent),
|
||
health: player.getComponent(HealthComponent),
|
||
inventory: player.getComponent(InventoryComponent)?.getItems(),
|
||
score: player.getComponent(ScoreComponent)?.score
|
||
};
|
||
}
|
||
|
||
private static extractSceneState(scene: Scene): any {
|
||
return {
|
||
enemies: this.extractEnemiesData(scene),
|
||
items: this.extractItemsData(scene),
|
||
level: this.getCurrentLevel(scene)
|
||
};
|
||
}
|
||
|
||
private static recreateScene(saveData: any): Scene {
|
||
const scene = new GameScene();
|
||
|
||
// 重建玩家
|
||
this.recreatePlayer(scene, saveData.playerData);
|
||
|
||
// 重建场景状态
|
||
this.recreateSceneState(scene, saveData.sceneState);
|
||
|
||
return scene;
|
||
}
|
||
}
|
||
|
||
// 自动保存系统
|
||
class AutoSaveSystem extends IntervalSystem {
|
||
constructor() {
|
||
super(30.0); // 每30秒自动保存
|
||
}
|
||
|
||
processSystem() {
|
||
SaveManager.saveScene(this.scene);
|
||
}
|
||
}
|
||
```
|
||
|
||
## 场景性能优化
|
||
|
||
### 1. 实体管理优化
|
||
|
||
```typescript
|
||
class OptimizedScene extends Scene {
|
||
private activeEntities: Set<Entity> = new Set();
|
||
private inactiveEntities: Set<Entity> = new Set();
|
||
|
||
createEntity(name?: string): Entity {
|
||
const entity = super.createEntity(name);
|
||
this.activeEntities.add(entity);
|
||
return entity;
|
||
}
|
||
|
||
destroyEntity(entity: Entity) {
|
||
this.activeEntities.delete(entity);
|
||
super.destroyEntity(entity);
|
||
}
|
||
|
||
// 暂时禁用实体而不销毁
|
||
deactivateEntity(entity: Entity) {
|
||
if (this.activeEntities.has(entity)) {
|
||
this.activeEntities.delete(entity);
|
||
this.inactiveEntities.add(entity);
|
||
entity.enabled = false;
|
||
}
|
||
}
|
||
|
||
// 重新激活实体
|
||
activateEntity(entity: Entity) {
|
||
if (this.inactiveEntities.has(entity)) {
|
||
this.inactiveEntities.delete(entity);
|
||
this.activeEntities.add(entity);
|
||
entity.enabled = true;
|
||
}
|
||
}
|
||
|
||
// 只更新活跃实体
|
||
update() {
|
||
for (const entity of this.activeEntities) {
|
||
if (entity.enabled) {
|
||
entity.update();
|
||
}
|
||
}
|
||
|
||
this.updateEntitySystems();
|
||
}
|
||
|
||
// 批量操作
|
||
deactivateAllEnemies() {
|
||
const enemies = this.findEntitiesWithTag(EntityTags.ENEMY);
|
||
enemies.forEach(enemy => this.deactivateEntity(enemy));
|
||
}
|
||
|
||
activateAllEnemies() {
|
||
const enemies = Array.from(this.inactiveEntities)
|
||
.filter(entity => entity.hasTag(EntityTags.ENEMY));
|
||
enemies.forEach(enemy => this.activateEntity(enemy));
|
||
}
|
||
}
|
||
```
|
||
|
||
### 2. 系统性能监控
|
||
|
||
```typescript
|
||
class PerformanceMonitoredScene extends Scene {
|
||
private systemPerformance: Map<string, number[]> = new Map();
|
||
|
||
addEntityProcessor<T extends EntitySystem>(system: T): T {
|
||
const wrappedSystem = this.wrapSystemWithMonitoring(system);
|
||
return super.addEntityProcessor(wrappedSystem);
|
||
}
|
||
|
||
private wrapSystemWithMonitoring<T extends EntitySystem>(system: T): T {
|
||
const originalUpdate = system.update.bind(system);
|
||
const systemName = system.constructor.name;
|
||
|
||
system.update = () => {
|
||
const startTime = performance.now();
|
||
originalUpdate();
|
||
const endTime = performance.now();
|
||
|
||
this.recordSystemPerformance(systemName, endTime - startTime);
|
||
};
|
||
|
||
return system;
|
||
}
|
||
|
||
private recordSystemPerformance(systemName: string, duration: number) {
|
||
if (!this.systemPerformance.has(systemName)) {
|
||
this.systemPerformance.set(systemName, []);
|
||
}
|
||
|
||
const records = this.systemPerformance.get(systemName)!;
|
||
records.push(duration);
|
||
|
||
// 只保留最近100次记录
|
||
if (records.length > 100) {
|
||
records.shift();
|
||
}
|
||
}
|
||
|
||
getPerformanceReport(): any {
|
||
const report = {};
|
||
|
||
this.systemPerformance.forEach((durations, systemName) => {
|
||
const avgDuration = durations.reduce((a, b) => a + b, 0) / durations.length;
|
||
const maxDuration = Math.max(...durations);
|
||
const minDuration = Math.min(...durations);
|
||
|
||
report[systemName] = {
|
||
average: avgDuration.toFixed(2) + 'ms',
|
||
max: maxDuration.toFixed(2) + 'ms',
|
||
min: minDuration.toFixed(2) + 'ms',
|
||
samples: durations.length
|
||
};
|
||
});
|
||
|
||
return report;
|
||
}
|
||
|
||
// 定期输出性能报告
|
||
private performanceReportTimer() {
|
||
Core.schedule(5.0, true, this, () => {
|
||
console.table(this.getPerformanceReport());
|
||
});
|
||
}
|
||
}
|
||
```
|
||
|
||
## 常见问题和最佳实践
|
||
|
||
### Q: 何时创建新场景？
|
||
|
||
A:
|
||
- 游戏的不同阶段（菜单、游戏、设置）
|
||
- 不同的关卡
|
||
- 需要完全不同系统配置的情况
|
||
- 需要清理大量实体时
|
||
|
||
### Q: 场景切换时如何保持数据？
|
||
|
||
A:
|
||
1. 使用场景构造函数传递数据
|
||
2. 使用全局数据管理器
|
||
3. 使用本地存储进行持久化
|
||
|
||
### Q: 如何优化场景性能？
|
||
|
||
A:
|
||
1. 合理使用实体的启用/禁用
|
||
2. 监控系统性能
|
||
3. 批量操作实体
|
||
4. 使用对象池减少垃圾回收
|
||
|
||
### Q: 多个场景可以同时存在吗？
|
||
|
||
A:
|
||
- **单Scene模式**：框架同时只支持一个活跃场景，但可以通过场景栈实现多场景管理（如暂停菜单）
|
||
- **多World模式**：每个World可以包含多个同时激活的Scene，支持复杂的多场景架构
|
||
|
||
### Q: 什么时候使用World系统？
|
||
|
||
A:
|
||
- 多人游戏服务器（每个房间独立管理）
|
||
- 需要并发运行多个独立游戏世界
|
||
- 复杂的客户端架构（游戏层、UI层、特效层分离）
|
||
- 需要跨Scene的全局系统支持
|
||
|
||
### Q: World和Scene的性能影响？
|
||
|
||
A:
|
||
- **单Scene模式**：最佳性能，适合简单项目
|
||
- **多World模式**：每个World独立更新，合理使用不会显著影响性能
|
||
- **建议**：根据项目复杂度选择合适的架构
|
||
|
||
### Q: 如何从单Scene迁移到多World？
|
||
|
||
A:
|
||
```typescript
|
||
// 原始单Scene代码
|
||
const scene = new Scene();
|
||
Core.setScene(scene);
|
||
|
||
// 迁移到World模式（可选）
|
||
Core.enableWorldManager();
|
||
const world = Core.getWorldManager().createWorld('MainWorld');
|
||
const scene = world.createScene('main', new Scene());
|
||
world.start();
|
||
world.setSceneActive('main', true);
|
||
```
|
||
|
||
### Q: World系统的最佳实践？
|
||
|
||
A:
|
||
1. **服务器端**：每个游戏房间使用独立World
|
||
2. **客户端**：按功能层级划分Scene（游戏、UI、特效）
|
||
3. **全局系统**：将跨Scene的逻辑放在World的全局System中
|
||
4. **资源管理**：使用World的autoCleanup功能自动清理空闲资源
|
||
|
||
通过合理选择单Scene或多World架构，你可以构建出结构清晰、性能优良的游戏架构！ |