A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
/**
* @file fakeEngine.ts
* @brief The C++ side of a World, modelled rather than stubbed.
*
* @details Component storage that add/get/has/remove really move, and a parent
* link both halves of which stay consistent — because the behaviour
* under test is what happens to entities and their children, and a
* stub that answers "no children" makes every subtree question pass.
*/
import { World } from '../../src/ecs/world';
import { COMPONENT_META } from '../../src/ecs/component.generated';
import type { CppRegistry } from '../../src/wasm';
/** What embind hands back for a `std::vector<Entity>`; the caller frees it. */
function entityVector(entities: number[]) {
return { size: () => entities.length, get: (i: number) => entities[i], delete: () => {} };
}
export function connectFakeCpp(world: World): void {
let nextEntity = 1;
const parentOf = new Map<number, number>();
const childrenOf = new Map<number, Set<number>>();
const rows = new Map<string, Map<number, Record<string, unknown>>>();
const unlink = (child: number): void => {
const parent = parentOf.get(child);
if (parent === undefined) return;
parentOf.delete(child);
childrenOf.get(parent)?.delete(child);
};
const registry: Record<string, unknown> = {};
for (const name of Object.keys(COMPONENT_META)) {
const store = new Map<number, Record<string, unknown>>();
rows.set(name, store);
registry[`add${name}`] = (e: number, data: Record<string, unknown>) => { store.set(e, { ...data }); };
registry[`get${name}`] = (e: number) => store.get(e);
registry[`has${name}`] = (e: number) => store.has(e);
registry[`remove${name}`] = (e: number) => { store.delete(e); };
}
// AFTER the generic pass: Parent and Children are not rows, they are two
// halves of one link, and the accessors named for them answer from it.
// Teardown ownership as Registry::reserveDestruction keeps it: one owner at a
// time. Every core binds it, so World takes it without asking.
const pendingTeardown = new Set<number>();
Object.assign(registry, {
reserveDestruction: (e: number) => {
if (pendingTeardown.has(e)) return false;
pendingTeardown.add(e);
return true;
},
releaseDestruction: (e: number) => { pendingTeardown.delete(e); },
destructionPending: (e: number) => pendingTeardown.has(e),
create: () => nextEntity++,
destroy: (e: number) => {
unlink(e);
childrenOf.delete(e);
for (const store of rows.values()) store.delete(e);
},
hasParent: (e: number) => parentOf.has(e),
getParent: (e: number) => ({ entity: parentOf.get(e) ?? 0 }),
setParent: (child: number, parent: number) => {
unlink(child);
if (!parent) return;
parentOf.set(child, parent);
let set = childrenOf.get(parent);
if (!set) { set = new Set(); childrenOf.set(parent, set); }
set.add(child);
},
removeParent: (e: number) => { unlink(e); },
addParent: (e: number, data: { entity?: number }) => {
if (data?.entity) (registry.setParent as (c: number, p: number) => void)(e, data.entity);
},
hasChildren: (e: number) => (childrenOf.get(e)?.size ?? 0) > 0,
getChildren: (e: number) => ({ entities: entityVector([...(childrenOf.get(e) ?? [])]) }),
addChildren: (e: number, data: { entities?: number[] }) => {
for (const child of data?.entities ?? []) {
(registry.setParent as (c: number, p: number) => void)(child, e);
}
},
removeChildren: (e: number) => {
for (const child of [...(childrenOf.get(e) ?? [])]) unlink(child);
},
});
world.connectCpp(registry as unknown as CppRegistry);
}