440 lines
16 KiB
TypeScript
440 lines
16 KiB
TypeScript
|
import { SceneSerializer } from '../../../src/ECS/Serialization/SceneSerializer';
|
||
|
|
import { Scene } from '../../../src/ECS/Scene';
|
||
|
|
import { Component } from '../../../src/ECS/Component';
|
||
|
|
import { HierarchySystem } from '../../../src/ECS/Systems/HierarchySystem';
|
||
|
|
import { ECSComponent } from '../../../src/ECS/Decorators';
|
||
|
|
import { ComponentRegistry, ComponentType } from '../../../src/ECS/Core/ComponentStorage';
|
||
|
|
import { Serializable, Serialize } from '../../../src/ECS/Serialization';
|
||
|
|
|
||
|
|
@ECSComponent('SceneSerTest_Position')
|
||
|
|
@Serializable({ version: 1 })
|
||
|
|
class PositionComponent extends Component {
|
||
|
|
@Serialize()
|
||
|
|
public x: number = 0;
|
||
|
|
|
||
|
|
@Serialize()
|
||
|
|
public y: number = 0;
|
||
|
|
|
||
|
|
constructor(x: number = 0, y: number = 0) {
|
||
|
|
super();
|
||
|
|
this.x = x;
|
||
|
|
this.y = y;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@ECSComponent('SceneSerTest_Velocity')
|
||
|
|
@Serializable({ version: 1 })
|
||
|
|
class VelocityComponent extends Component {
|
||
|
|
@Serialize()
|
||
|
|
public vx: number = 0;
|
||
|
|
|
||
|
|
@Serialize()
|
||
|
|
public vy: number = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
describe('SceneSerializer', () => {
|
||
|
|
let scene: Scene;
|
||
|
|
let componentRegistry: Map<string, ComponentType>;
|
||
|
|
|
||
|
|
beforeEach(() => {
|
||
|
|
ComponentRegistry.reset();
|
||
|
|
ComponentRegistry.register(PositionComponent);
|
||
|
|
ComponentRegistry.register(VelocityComponent);
|
||
|
|
|
||
|
|
scene = new Scene({ name: 'SceneSerializerTestScene' });
|
||
|
|
|
||
|
|
componentRegistry = ComponentRegistry.getAllComponentNames() as Map<string, ComponentType>;
|
||
|
|
});
|
||
|
|
|
||
|
|
afterEach(() => {
|
||
|
|
scene.end();
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('serialize', () => {
|
||
|
|
test('should serialize scene to JSON string', () => {
|
||
|
|
scene.createEntity('Entity1').addComponent(new PositionComponent(10, 20));
|
||
|
|
scene.createEntity('Entity2').addComponent(new VelocityComponent());
|
||
|
|
|
||
|
|
const result = SceneSerializer.serialize(scene);
|
||
|
|
|
||
|
|
expect(typeof result).toBe('string');
|
||
|
|
const parsed = JSON.parse(result as string);
|
||
|
|
expect(parsed.name).toBe('SceneSerializerTestScene');
|
||
|
|
expect(parsed.entities.length).toBe(2);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should serialize scene to binary format', () => {
|
||
|
|
scene.createEntity('Entity');
|
||
|
|
|
||
|
|
const result = SceneSerializer.serialize(scene, { format: 'binary' });
|
||
|
|
|
||
|
|
expect(result).toBeInstanceOf(Uint8Array);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should include metadata when requested', () => {
|
||
|
|
scene.createEntity('Entity');
|
||
|
|
|
||
|
|
const result = SceneSerializer.serialize(scene, { includeMetadata: true });
|
||
|
|
const parsed = JSON.parse(result as string);
|
||
|
|
|
||
|
|
expect(parsed.metadata).toBeDefined();
|
||
|
|
expect(parsed.metadata.entityCount).toBe(1);
|
||
|
|
expect(parsed.timestamp).toBeDefined();
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should pretty print JSON when requested', () => {
|
||
|
|
scene.createEntity('Entity');
|
||
|
|
|
||
|
|
const result = SceneSerializer.serialize(scene, { pretty: true });
|
||
|
|
|
||
|
|
expect(typeof result).toBe('string');
|
||
|
|
expect((result as string).includes('\n')).toBe(true);
|
||
|
|
expect((result as string).includes(' ')).toBe(true);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should serialize scene data', () => {
|
||
|
|
scene.sceneData.set('level', 5);
|
||
|
|
scene.sceneData.set('config', { difficulty: 'hard' });
|
||
|
|
|
||
|
|
const result = SceneSerializer.serialize(scene);
|
||
|
|
const parsed = JSON.parse(result as string);
|
||
|
|
|
||
|
|
expect(parsed.sceneData).toBeDefined();
|
||
|
|
expect(parsed.sceneData.level).toBe(5);
|
||
|
|
expect(parsed.sceneData.config.difficulty).toBe('hard');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should serialize with component filter', () => {
|
||
|
|
scene.createEntity('Entity1').addComponent(new PositionComponent());
|
||
|
|
scene.createEntity('Entity2').addComponent(new VelocityComponent());
|
||
|
|
|
||
|
|
const result = SceneSerializer.serialize(scene, {
|
||
|
|
components: [PositionComponent]
|
||
|
|
});
|
||
|
|
const parsed = JSON.parse(result as string);
|
||
|
|
|
||
|
|
// Only entities with PositionComponent should be included
|
||
|
|
expect(parsed.entities.length).toBe(1);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('deserialize', () => {
|
||
|
|
test('should deserialize scene from JSON string', () => {
|
||
|
|
scene.createEntity('Entity1').addComponent(new PositionComponent(100, 200));
|
||
|
|
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
|
||
|
|
const newScene = new Scene({ name: 'NewScene' });
|
||
|
|
SceneSerializer.deserialize(newScene, serialized, { componentRegistry });
|
||
|
|
|
||
|
|
expect(newScene.entities.count).toBe(1);
|
||
|
|
const entity = newScene.findEntity('Entity1');
|
||
|
|
expect(entity).not.toBeNull();
|
||
|
|
expect(entity!.hasComponent(PositionComponent)).toBe(true);
|
||
|
|
|
||
|
|
const pos = entity!.getComponent(PositionComponent)!;
|
||
|
|
expect(pos.x).toBe(100);
|
||
|
|
expect(pos.y).toBe(200);
|
||
|
|
|
||
|
|
newScene.end();
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should deserialize scene from binary format', () => {
|
||
|
|
scene.createEntity('BinaryEntity').addComponent(new PositionComponent(50, 75));
|
||
|
|
|
||
|
|
const serialized = SceneSerializer.serialize(scene, { format: 'binary' });
|
||
|
|
|
||
|
|
const newScene = new Scene({ name: 'NewScene' });
|
||
|
|
SceneSerializer.deserialize(newScene, serialized, { componentRegistry });
|
||
|
|
|
||
|
|
expect(newScene.entities.count).toBe(1);
|
||
|
|
const entity = newScene.findEntity('BinaryEntity');
|
||
|
|
expect(entity).not.toBeNull();
|
||
|
|
|
||
|
|
newScene.end();
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should replace existing entities with strategy replace', () => {
|
||
|
|
scene.createEntity('Original');
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
|
||
|
|
const targetScene = new Scene({ name: 'Target' });
|
||
|
|
targetScene.createEntity('Existing1');
|
||
|
|
targetScene.createEntity('Existing2');
|
||
|
|
expect(targetScene.entities.count).toBe(2);
|
||
|
|
|
||
|
|
SceneSerializer.deserialize(targetScene, serialized, {
|
||
|
|
strategy: 'replace',
|
||
|
|
componentRegistry
|
||
|
|
});
|
||
|
|
|
||
|
|
expect(targetScene.entities.count).toBe(1);
|
||
|
|
expect(targetScene.findEntity('Original')).not.toBeNull();
|
||
|
|
expect(targetScene.findEntity('Existing1')).toBeNull();
|
||
|
|
|
||
|
|
targetScene.end();
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should merge with existing entities with strategy merge', () => {
|
||
|
|
scene.createEntity('FromSave');
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
|
||
|
|
const targetScene = new Scene({ name: 'Target' });
|
||
|
|
targetScene.createEntity('Existing');
|
||
|
|
expect(targetScene.entities.count).toBe(1);
|
||
|
|
|
||
|
|
SceneSerializer.deserialize(targetScene, serialized, {
|
||
|
|
strategy: 'merge',
|
||
|
|
componentRegistry
|
||
|
|
});
|
||
|
|
|
||
|
|
expect(targetScene.entities.count).toBe(2);
|
||
|
|
expect(targetScene.findEntity('Existing')).not.toBeNull();
|
||
|
|
expect(targetScene.findEntity('FromSave')).not.toBeNull();
|
||
|
|
|
||
|
|
targetScene.end();
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should restore scene data', () => {
|
||
|
|
scene.sceneData.set('weather', 'sunny');
|
||
|
|
scene.sceneData.set('time', 12.5);
|
||
|
|
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
|
||
|
|
const newScene = new Scene({ name: 'NewScene' });
|
||
|
|
SceneSerializer.deserialize(newScene, serialized, { componentRegistry });
|
||
|
|
|
||
|
|
expect(newScene.sceneData.get('weather')).toBe('sunny');
|
||
|
|
expect(newScene.sceneData.get('time')).toBe(12.5);
|
||
|
|
|
||
|
|
newScene.end();
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should call migration function when versions differ', () => {
|
||
|
|
scene.createEntity('Entity');
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
|
||
|
|
// Manually modify version
|
||
|
|
const parsed = JSON.parse(serialized as string);
|
||
|
|
parsed.version = 0;
|
||
|
|
const modifiedSerialized = JSON.stringify(parsed);
|
||
|
|
|
||
|
|
const migrationFn = jest.fn((oldVersion, newVersion, data) => {
|
||
|
|
expect(oldVersion).toBe(0);
|
||
|
|
return data;
|
||
|
|
});
|
||
|
|
|
||
|
|
const newScene = new Scene({ name: 'NewScene' });
|
||
|
|
SceneSerializer.deserialize(newScene, modifiedSerialized, {
|
||
|
|
componentRegistry,
|
||
|
|
migration: migrationFn
|
||
|
|
});
|
||
|
|
|
||
|
|
expect(migrationFn).toHaveBeenCalled();
|
||
|
|
|
||
|
|
newScene.end();
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should throw on invalid JSON', () => {
|
||
|
|
const newScene = new Scene({ name: 'NewScene' });
|
||
|
|
|
||
|
|
expect(() => {
|
||
|
|
SceneSerializer.deserialize(newScene, 'invalid json{{{', { componentRegistry });
|
||
|
|
}).toThrow();
|
||
|
|
|
||
|
|
newScene.end();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('validate', () => {
|
||
|
|
test('should validate correct save data', () => {
|
||
|
|
scene.createEntity('Entity');
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
|
||
|
|
const result = SceneSerializer.validate(serialized as string);
|
||
|
|
|
||
|
|
expect(result.valid).toBe(true);
|
||
|
|
expect(result.version).toBe(1);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should return errors for missing version', () => {
|
||
|
|
const invalid = JSON.stringify({ entities: [], componentTypeRegistry: [] });
|
||
|
|
|
||
|
|
const result = SceneSerializer.validate(invalid);
|
||
|
|
|
||
|
|
expect(result.valid).toBe(false);
|
||
|
|
expect(result.errors).toContain('Missing version field');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should return errors for missing entities', () => {
|
||
|
|
const invalid = JSON.stringify({ version: 1, componentTypeRegistry: [] });
|
||
|
|
|
||
|
|
const result = SceneSerializer.validate(invalid);
|
||
|
|
|
||
|
|
expect(result.valid).toBe(false);
|
||
|
|
expect(result.errors).toContain('Missing or invalid entities field');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should return errors for missing componentTypeRegistry', () => {
|
||
|
|
const invalid = JSON.stringify({ version: 1, entities: [] });
|
||
|
|
|
||
|
|
const result = SceneSerializer.validate(invalid);
|
||
|
|
|
||
|
|
expect(result.valid).toBe(false);
|
||
|
|
expect(result.errors).toContain('Missing or invalid componentTypeRegistry field');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should handle JSON parse errors', () => {
|
||
|
|
const result = SceneSerializer.validate('not valid json');
|
||
|
|
|
||
|
|
expect(result.valid).toBe(false);
|
||
|
|
expect(result.errors).toBeDefined();
|
||
|
|
expect(result.errors![0]).toContain('JSON parse error');
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('getInfo', () => {
|
||
|
|
test('should return info from save data', () => {
|
||
|
|
scene.name = 'InfoTestScene';
|
||
|
|
scene.createEntity('Entity1');
|
||
|
|
scene.createEntity('Entity2');
|
||
|
|
scene.createEntity('Entity3');
|
||
|
|
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
const info = SceneSerializer.getInfo(serialized as string);
|
||
|
|
|
||
|
|
expect(info).not.toBeNull();
|
||
|
|
expect(info!.name).toBe('InfoTestScene');
|
||
|
|
expect(info!.entityCount).toBe(3);
|
||
|
|
expect(info!.version).toBe(1);
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should return null for invalid data', () => {
|
||
|
|
const info = SceneSerializer.getInfo('invalid');
|
||
|
|
|
||
|
|
expect(info).toBeNull();
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should include timestamp when present', () => {
|
||
|
|
scene.createEntity('Entity');
|
||
|
|
const serialized = SceneSerializer.serialize(scene, { includeMetadata: true });
|
||
|
|
const info = SceneSerializer.getInfo(serialized as string);
|
||
|
|
|
||
|
|
expect(info!.timestamp).toBeDefined();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('scene data serialization', () => {
|
||
|
|
test('should serialize Date objects', () => {
|
||
|
|
const date = new Date('2024-01-01T00:00:00Z');
|
||
|
|
scene.sceneData.set('createdAt', date);
|
||
|
|
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
const parsed = JSON.parse(serialized as string);
|
||
|
|
|
||
|
|
expect(parsed.sceneData.createdAt.__type).toBe('Date');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should deserialize Date objects', () => {
|
||
|
|
const date = new Date('2024-01-01T00:00:00Z');
|
||
|
|
scene.sceneData.set('createdAt', date);
|
||
|
|
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
|
||
|
|
const newScene = new Scene({ name: 'NewScene' });
|
||
|
|
SceneSerializer.deserialize(newScene, serialized, { componentRegistry });
|
||
|
|
|
||
|
|
const restoredDate = newScene.sceneData.get('createdAt');
|
||
|
|
expect(restoredDate).toBeInstanceOf(Date);
|
||
|
|
expect(restoredDate.getTime()).toBe(date.getTime());
|
||
|
|
|
||
|
|
newScene.end();
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should serialize Map objects', () => {
|
||
|
|
const map = new Map([['key1', 'value1'], ['key2', 'value2']]);
|
||
|
|
scene.sceneData.set('mapping', map);
|
||
|
|
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
const parsed = JSON.parse(serialized as string);
|
||
|
|
|
||
|
|
expect(parsed.sceneData.mapping.__type).toBe('Map');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should deserialize Map objects', () => {
|
||
|
|
const map = new Map([['key1', 'value1'], ['key2', 'value2']]);
|
||
|
|
scene.sceneData.set('mapping', map);
|
||
|
|
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
|
||
|
|
const newScene = new Scene({ name: 'NewScene' });
|
||
|
|
SceneSerializer.deserialize(newScene, serialized, { componentRegistry });
|
||
|
|
|
||
|
|
const restoredMap = newScene.sceneData.get('mapping');
|
||
|
|
expect(restoredMap).toBeInstanceOf(Map);
|
||
|
|
expect(restoredMap.get('key1')).toBe('value1');
|
||
|
|
expect(restoredMap.get('key2')).toBe('value2');
|
||
|
|
|
||
|
|
newScene.end();
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should serialize Set objects', () => {
|
||
|
|
const set = new Set([1, 2, 3]);
|
||
|
|
scene.sceneData.set('numbers', set);
|
||
|
|
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
const parsed = JSON.parse(serialized as string);
|
||
|
|
|
||
|
|
expect(parsed.sceneData.numbers.__type).toBe('Set');
|
||
|
|
});
|
||
|
|
|
||
|
|
test('should deserialize Set objects', () => {
|
||
|
|
const set = new Set([1, 2, 3]);
|
||
|
|
scene.sceneData.set('numbers', set);
|
||
|
|
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
|
||
|
|
const newScene = new Scene({ name: 'NewScene' });
|
||
|
|
SceneSerializer.deserialize(newScene, serialized, { componentRegistry });
|
||
|
|
|
||
|
|
const restoredSet = newScene.sceneData.get('numbers');
|
||
|
|
expect(restoredSet).toBeInstanceOf(Set);
|
||
|
|
expect(restoredSet.has(1)).toBe(true);
|
||
|
|
expect(restoredSet.has(2)).toBe(true);
|
||
|
|
expect(restoredSet.has(3)).toBe(true);
|
||
|
|
|
||
|
|
newScene.end();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('hierarchy serialization', () => {
|
||
|
|
test('should serialize and deserialize entity hierarchy', () => {
|
||
|
|
const hierarchySystem = new HierarchySystem();
|
||
|
|
scene.addSystem(hierarchySystem);
|
||
|
|
|
||
|
|
const root = scene.createEntity('Root');
|
||
|
|
const child1 = scene.createEntity('Child1');
|
||
|
|
const child2 = scene.createEntity('Child2');
|
||
|
|
|
||
|
|
hierarchySystem.setParent(child1, root);
|
||
|
|
hierarchySystem.setParent(child2, root);
|
||
|
|
|
||
|
|
const serialized = SceneSerializer.serialize(scene);
|
||
|
|
|
||
|
|
const newScene = new Scene({ name: 'NewScene' });
|
||
|
|
const newHierarchySystem = new HierarchySystem();
|
||
|
|
newScene.addSystem(newHierarchySystem);
|
||
|
|
|
||
|
|
SceneSerializer.deserialize(newScene, serialized, { componentRegistry });
|
||
|
|
|
||
|
|
const newRoot = newScene.findEntity('Root');
|
||
|
|
expect(newRoot).not.toBeNull();
|
||
|
|
|
||
|
|
const children = newHierarchySystem.getChildren(newRoot!);
|
||
|
|
expect(children.length).toBe(2);
|
||
|
|
|
||
|
|
newScene.end();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|