@dcl/ecs 7.0.0-3532389879.commit-c89c80c → 7.0.0-3568547351.commit-5420eac

package/dist/components/generated/types.gen.d.ts

@@ -0,0 +1,6 @@
+export type { Position as PBPosition, Vector2 as PBVector2, Vector3 as PBVector3 } from './pb/decentraland/common/vectors.gen';
+export type { Color3 as PBColor3, Color4 as PBColor4 } from './pb/decentraland/common/colors.gen';
+export * from './pb/decentraland/sdk/components/common/camera_type.gen';
+export * from './pb/decentraland/sdk/components/common/input_action.gen';
+export * from './pb/decentraland/sdk/components/common/texts.gen';
+export * from './pb/decentraland/common/texture.gen';

package/dist/components/generated/types.gen.js

@@ -0,0 +1,8 @@
+export * from './pb/decentraland/sdk/components/common/camera_type.gen';
+// export { PbCameraType }
+export * from './pb/decentraland/sdk/components/common/input_action.gen';
+// export { PbInputAction }
+export * from './pb/decentraland/sdk/components/common/texts.gen';
+// export { PbTexts }
+export * from './pb/decentraland/common/texture.gen';
+// export { PbTexture }

package/dist/components/index.d.ts

@@ -0,0 +1,15 @@
+import { ISchema } from '../engine';
+import { ComponentGetter } from './generated/index.gen';
+export * from './generated/index.gen';
+import { TransformComponent } from './legacy/Transform';
+import { AnimatorComponentDefinitionExtended } from './extended/Animator';
+import { MeshColliderComponentDefinitionExtended } from './extended/MeshCollider';
+import { MeshRendererComponentDefinitionExtended } from './extended/MeshRenderer';
+import { MaterialComponentDefinitionExtended } from './extended/Material';
+import { ComponentDefinition } from '../engine/component';
+export { ISchema, ComponentDefinition };
+export declare const Transform: ComponentGetter<TransformComponent>;
+export declare const Material: ComponentGetter<MaterialComponentDefinitionExtended>;
+export declare const Animator: ComponentGetter<AnimatorComponentDefinitionExtended>;
+export declare const MeshRenderer: ComponentGetter<MeshRendererComponentDefinitionExtended>;
+export declare const MeshCollider: ComponentGetter<MeshColliderComponentDefinitionExtended>;

package/dist/components/index.js

@@ -0,0 +1,16 @@
+export * from './generated/index.gen';
+import { defineTransformComponent } from './legacy/Transform';
+import { defineAnimatorComponent } from './extended/Animator';
+import { defineMeshColliderComponent } from './extended/MeshCollider';
+import { defineMeshRendererComponent } from './extended/MeshRenderer';
+import { defineMaterialComponent } from './extended/Material';
+/*#__PURE__*/
+export const Transform = (engine) => defineTransformComponent(engine);
+/*#__PURE__*/
+export const Material = (engine) => defineMaterialComponent(engine);
+/*#__PURE__*/
+export const Animator = (engine) => defineAnimatorComponent(engine);
+/*#__PURE__*/
+export const MeshRenderer = (engine) => defineMeshRendererComponent(engine);
+/*#__PURE__*/
+export const MeshCollider = (engine) => defineMeshColliderComponent(engine);

package/dist/components/legacy/Transform.d.ts

@@ -0,0 +1,27 @@
+import type { ISchema } from '../../schemas/ISchema';
+import { Entity } from '../../engine/entity';
+import { ComponentDefinition, IEngine } from '../../engine';
+export declare type TransformComponent = ComponentDefinition<ISchema<TransformType>, Partial<TransformType>>;
+/**
+ * @public
+ */
+export declare type TransformType = {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    parent?: Entity;
+};
+export declare function defineTransformComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): ComponentDefinition<ISchema<TransformType>, Partial<TransformType>>;

package/dist/components/legacy/Transform.js

@@ -0,0 +1,55 @@
+/**
+ * @internal
+ */
+export const COMPONENT_ID = 1;
+/** @internal */
+export const TRANSFORM_LENGTH = 44;
+/** @internal */
+export const TransformSchema = {
+    serialize(value, builder) {
+        const ptr = builder.incrementWriteOffset(TRANSFORM_LENGTH);
+        builder.setFloat32(ptr, value.position.x);
+        builder.setFloat32(ptr + 4, value.position.y);
+        builder.setFloat32(ptr + 8, value.position.z);
+        builder.setFloat32(ptr + 12, value.rotation.x);
+        builder.setFloat32(ptr + 16, value.rotation.y);
+        builder.setFloat32(ptr + 20, value.rotation.z);
+        builder.setFloat32(ptr + 24, value.rotation.w);
+        builder.setFloat32(ptr + 28, value.scale.x);
+        builder.setFloat32(ptr + 32, value.scale.y);
+        builder.setFloat32(ptr + 36, value.scale.z);
+        builder.setUint32(ptr + 40, value.parent || 0);
+    },
+    deserialize(reader) {
+        const ptr = reader.incrementReadOffset(TRANSFORM_LENGTH);
+        return {
+            position: {
+                x: reader.getFloat32(ptr),
+                y: reader.getFloat32(ptr + 4),
+                z: reader.getFloat32(ptr + 8)
+            },
+            rotation: {
+                x: reader.getFloat32(ptr + 12),
+                y: reader.getFloat32(ptr + 16),
+                z: reader.getFloat32(ptr + 20),
+                w: reader.getFloat32(ptr + 24)
+            },
+            scale: {
+                x: reader.getFloat32(ptr + 28),
+                y: reader.getFloat32(ptr + 32),
+                z: reader.getFloat32(ptr + 36)
+            },
+            parent: reader.getUint32(ptr + 40)
+        };
+    },
+    create() {
+        return {
+            position: { x: 0, y: 0, z: 0 },
+            scale: { x: 1, y: 1, z: 1 },
+            rotation: { x: 0, y: 0, z: 0, w: 1 }
+        };
+    }
+};
+export function defineTransformComponent(engine) {
+    return engine.defineComponentFromSchema(TransformSchema, COMPONENT_ID);
+}

package/dist/components/types.d.ts

@@ -0,0 +1,4 @@
+export type { AnimatorComponentDefinition, AnimatorComponentDefinitionExtended } from './extended/Animator';
+export type { MeshRendererComponentDefinition, MeshRendererComponentDefinitionExtended } from './extended/MeshRenderer';
+export type { MeshColliderComponentDefinition, MeshColliderComponentDefinitionExtended } from './extended/MeshCollider';
+export type { TextureHelper, MaterialComponentDefinition, MaterialComponentDefinitionExtended } from './extended/Material';

package/dist/components/types.js

@@ -0,0 +1 @@
+export {};

package/dist/engine/component.d.ts

@@ -0,0 +1,72 @@
+import type { ISchema } from '../schemas/ISchema';
+import { ByteBuffer } from '../serialization/ByteBuffer';
+import { Entity } from './entity';
+import { DeepReadonly } from './readonly';
+/**
+ * @public
+ */
+export declare type EcsResult<T extends ISchema> = T extends ISchema ? ReturnType<T['deserialize']> : never;
+/**
+ * @public
+ */
+export declare type ComponentType<T extends ISchema> = EcsResult<T>;
+/**
+ * @public
+ */
+export declare type ComponentDefinition<T extends ISchema<ConstructorType>, ConstructorType = any> = {
+    _id: number;
+    /**
+     * Return the default value of the current component
+     */
+    default(): DeepReadonly<ComponentType<T>>;
+    /**
+     * Get if the entity has this component
+     * @param entity - entity to test
+     */
+    has(entity: Entity): boolean;
+    /**
+     * Get the readonly component of the entity (to mutate it, use getMutable instead), throw an error if the entity doesn't have the component.
+     * @param entity - Entity that will be used to get the component
+     * @returns
+     */
+    get(entity: Entity): DeepReadonly<ComponentType<T>>;
+    /**
+     * Get the readonly component of the entity (to mutate it, use getMutable instead), or null if the entity doesn't have the component.
+     * @param entity - Entity that will be used to try to get the component
+     */
+    getOrNull(entity: Entity): DeepReadonly<ComponentType<T>> | null;
+    /**
+     * Add the current component to an entity, throw an error if the component already exists (use `createOrReplace` instead).
+     * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
+     * @param entity - Entity that will be used to create the component
+     * @param val - The initial value
+     */
+    create(entity: Entity, val?: ConstructorType): ComponentType<T>;
+    /**
+     * Add the current component to an entity or replace the content if the entity already has the component
+     * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
+     * @param entity - Entity that will be used to create or replace the component
+     * @param val - The initial or new value
+     */
+    createOrReplace(entity: Entity, val?: ConstructorType): ComponentType<T>;
+    /**
+     * Delete the current component to an entity, return null if the entity doesn't have the current component.
+     * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
+     * @param entity - Entity to delete the component from
+     */
+    deleteFrom(entity: Entity): ComponentType<T> | null;
+    /**
+     * Get the mutable component of the entity, throw an error if the entity doesn't have the component.
+     * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
+     * @param entity - Entity to get the component from
+     */
+    getMutable(entity: Entity): ComponentType<T>;
+    /**
+     * Get the mutable component of the entity, return null if the entity doesn't have the component.
+     * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
+     * @param entity - Entity to get the component from
+     */
+    getMutableOrNull(entity: Entity): ComponentType<T> | null;
+    writeToByteBuffer(entity: Entity, buffer: ByteBuffer): void;
+};
+export declare function defineComponent<T extends ISchema, ConstructorType = ComponentType<T>>(componentId: number, spec: T, constructorDefault?: ConstructorType): ComponentDefinition<T, ConstructorType>;

package/dist/engine/component.js

@@ -0,0 +1,130 @@
+import { createByteBuffer } from '../serialization/ByteBuffer';
+import { deepReadonly } from './readonly';
+export function defineComponent(componentId, spec, constructorDefault
+// meta: { syncFlags }
+) {
+    const data = new Map();
+    const dirtyIterator = new Set();
+    const defaultBuffer = createByteBuffer();
+    if (constructorDefault) {
+        spec.serialize(constructorDefault, defaultBuffer);
+    }
+    function getDefaultValue() {
+        if (constructorDefault) {
+            return spec.deserialize(createByteBuffer({
+                writing: {
+                    buffer: defaultBuffer.buffer(),
+                    currentOffset: defaultBuffer.currentWriteOffset()
+                }
+            }));
+        }
+        else {
+            return spec.create();
+        }
+    }
+    function prefillValue(value) {
+        return { ...getDefaultValue(), ...value };
+    }
+    return {
+        _id: componentId,
+        default() {
+            return getDefaultValue();
+        },
+        isDirty(entity) {
+            return dirtyIterator.has(entity);
+        },
+        has(entity) {
+            return data.has(entity);
+        },
+        deleteFrom(entity) {
+            const component = data.get(entity);
+            data.delete(entity);
+            dirtyIterator.add(entity);
+            return component || null;
+        },
+        getOrNull(entity) {
+            const component = data.get(entity);
+            return component ? deepReadonly(component) : null;
+        },
+        get(entity) {
+            const component = data.get(entity);
+            if (!component) {
+                throw new Error(`[getFrom] Component ${componentId} for entity #${entity} not found`);
+            }
+            return deepReadonly(component);
+        },
+        create(entity, value) {
+            const component = data.get(entity);
+            if (component) {
+                throw new Error(`[create] Component ${componentId} for ${entity} already exists`);
+            }
+            const usedValue = value === undefined ? getDefaultValue() : prefillValue(value);
+            data.set(entity, usedValue);
+            dirtyIterator.add(entity);
+            return usedValue;
+        },
+        createOrReplace(entity, value) {
+            const usedValue = value === undefined ? getDefaultValue() : prefillValue(value);
+            data.set(entity, usedValue);
+            dirtyIterator.add(entity);
+            return usedValue;
+        },
+        getMutableOrNull(entity) {
+            const component = data.get(entity);
+            if (!component) {
+                return null;
+            }
+            dirtyIterator.add(entity);
+            return component;
+        },
+        getMutable(entity) {
+            const component = this.getMutableOrNull(entity);
+            if (component === null) {
+                throw new Error(`[mutable] Component ${componentId} for ${entity} not found`);
+            }
+            return component;
+        },
+        *iterator() {
+            for (const [entity, component] of data) {
+                yield [entity, component];
+            }
+        },
+        *dirtyIterator() {
+            for (const entity of dirtyIterator) {
+                yield entity;
+            }
+        },
+        toBinary(entity) {
+            const component = data.get(entity);
+            if (!component) {
+                throw new Error(`[toBinary] Component ${componentId} for ${entity} not found`);
+            }
+            const writeBuffer = createByteBuffer();
+            spec.serialize(component, writeBuffer);
+            return writeBuffer;
+        },
+        writeToByteBuffer(entity, buffer) {
+            const component = data.get(entity);
+            if (!component) {
+                throw new Error(`[writeToByteBuffer] Component ${componentId} for entity #${entity} not found`);
+            }
+            spec.serialize(component, buffer);
+        },
+        updateFromBinary(entity, buffer) {
+            const component = data.get(entity);
+            if (!component) {
+                throw new Error(`[updateFromBinary] Component ${componentId} for ${entity} not found`);
+            }
+            return this.upsertFromBinary(entity, buffer);
+        },
+        upsertFromBinary(entity, buffer) {
+            const newValue = spec.deserialize(buffer);
+            data.set(entity, newValue);
+            dirtyIterator.add(entity);
+            return newValue;
+        },
+        clearDirty() {
+            dirtyIterator.clear();
+        }
+    };
+}

package/dist/engine/entity-utils.d.ts

@@ -0,0 +1,18 @@
+import { Entity } from './entity';
+export declare namespace EntityUtils {
+    /**
+     * Range is the first element and the last possible element, they both are included in the interval.
+     * [start, end]
+     */
+    type EntityRange = readonly [number, number];
+    const MAX_ENTITIES = 4294967295;
+    const DYNAMIC_ENTITIES_START_AT = 100000;
+    const RESERVED_STATIC_ENTITIES = 512;
+    const RESERVED_ENTITIES_RANGE: EntityRange;
+    const STATIC_ENTITIES_RANGE: EntityRange;
+    const DYNAMIC_ENTITIES_RANGE: EntityRange;
+    function isDynamicEntity(entity: Entity): boolean;
+    function isStaticEntity(entity: Entity): boolean;
+    function isReservedEntity(entity: Entity): boolean;
+}
+export default EntityUtils;

package/dist/engine/entity-utils.js

@@ -0,0 +1,34 @@
+export var EntityUtils;
+(function (EntityUtils) {
+    EntityUtils.MAX_ENTITIES = 0xffffffff;
+    EntityUtils.DYNAMIC_ENTITIES_START_AT = 100e3;
+    EntityUtils.RESERVED_STATIC_ENTITIES = 512;
+    EntityUtils.RESERVED_ENTITIES_RANGE = [
+        0,
+        EntityUtils.RESERVED_STATIC_ENTITIES - 1
+    ];
+    EntityUtils.STATIC_ENTITIES_RANGE = [
+        EntityUtils.RESERVED_STATIC_ENTITIES,
+        EntityUtils.DYNAMIC_ENTITIES_START_AT - 1
+    ];
+    EntityUtils.DYNAMIC_ENTITIES_RANGE = [
+        EntityUtils.DYNAMIC_ENTITIES_START_AT,
+        EntityUtils.MAX_ENTITIES
+    ];
+    function isInRange(entity, range) {
+        return entity >= range[0] && entity <= range[1];
+    }
+    function isDynamicEntity(entity) {
+        return isInRange(entity, EntityUtils.DYNAMIC_ENTITIES_RANGE);
+    }
+    EntityUtils.isDynamicEntity = isDynamicEntity;
+    function isStaticEntity(entity) {
+        return isInRange(entity, EntityUtils.STATIC_ENTITIES_RANGE);
+    }
+    EntityUtils.isStaticEntity = isStaticEntity;
+    function isReservedEntity(entity) {
+        return isInRange(entity, EntityUtils.RESERVED_ENTITIES_RANGE);
+    }
+    EntityUtils.isReservedEntity = isReservedEntity;
+})(EntityUtils || (EntityUtils = {}));
+export default EntityUtils;

package/dist/engine/entity.d.ts

@@ -0,0 +1,17 @@
+import { EntityUtils } from './entity-utils';
+/**
+ * @public
+ */
+export declare type Entity = unknown;
+export declare function EntityContainer(): {
+    generateEntity(dynamic?: boolean): Entity;
+    removeEntity(entity: Entity): boolean;
+    entityExists(entity: Entity): boolean;
+    getExistingEntities(): Set<Entity>;
+};
+declare function Entity(range: EntityUtils.EntityRange): {
+    getExistingEntities(): Set<unknown>;
+    generateEntity: () => Entity;
+    removeEntity: (entity: Entity) => boolean;
+};
+export {};

package/dist/engine/entity.js

@@ -0,0 +1,55 @@
+import { EntityUtils } from './entity-utils';
+export function EntityContainer() {
+    const staticEntity = Entity(EntityUtils.STATIC_ENTITIES_RANGE);
+    const dynamicEntity = Entity(EntityUtils.DYNAMIC_ENTITIES_RANGE);
+    return {
+        generateEntity(dynamic = false) {
+            if (dynamic) {
+                return dynamicEntity.generateEntity();
+            }
+            else {
+                return staticEntity.generateEntity();
+            }
+        },
+        removeEntity(entity) {
+            return (staticEntity.removeEntity(entity) || dynamicEntity.removeEntity(entity));
+        },
+        entityExists(entity) {
+            return (EntityUtils.isReservedEntity(entity) ||
+                staticEntity.getExistingEntities().has(entity) ||
+                dynamicEntity.getExistingEntities().has(entity));
+        },
+        getExistingEntities() {
+            return new Set([
+                ...staticEntity.getExistingEntities(),
+                ...dynamicEntity.getExistingEntities()
+            ]);
+        }
+    };
+}
+function Entity(range) {
+    function createEntity(entity) {
+        return entity;
+    }
+    let entityCounter = range[0];
+    const usedEntities = new Set();
+    function generateEntity() {
+        if (entityCounter >= range[1]) {
+            throw new Error(`It fails trying to generate an entity out of range [${range[0]}, ${range[1]}].`);
+        }
+        const entity = createEntity(entityCounter);
+        entityCounter++;
+        usedEntities.add(entity);
+        return entity;
+    }
+    function removeEntity(entity) {
+        return usedEntities.delete(entity);
+    }
+    return {
+        getExistingEntities() {
+            return new Set(usedEntities);
+        },
+        generateEntity,
+        removeEntity
+    };
+}

package/dist/engine/index.d.ts

@@ -0,0 +1,12 @@
+import { ByteBuffer } from '../serialization/ByteBuffer';
+import { ComponentDefinition, ComponentType } from './component';
+import { Entity } from './entity';
+import type { IEngine } from './types';
+export * from './input';
+export * from './readonly';
+export * from './types';
+export { ComponentType, Entity, ByteBuffer, ComponentDefinition };
+/**
+ * @public
+ */
+export declare function Engine(): IEngine;

package/dist/engine/index.js

@@ -0,0 +1,172 @@
+import * as components from '../components';
+import { Schemas } from '../schemas';
+import { crdtSceneSystem } from '../systems/crdt';
+import { defineComponent as defComponent } from './component';
+import { EntityContainer } from './entity';
+import { SystemContainer, SYSTEMS_REGULAR_PRIORITY } from './systems';
+export * from './input';
+export * from './readonly';
+export * from './types';
+function preEngine() {
+    const entityContainer = EntityContainer();
+    const componentsDefinition = new Map();
+    const systems = SystemContainer();
+    function addSystem(fn, priority = SYSTEMS_REGULAR_PRIORITY, name) {
+        systems.add(fn, priority, name);
+    }
+    function removeSystem(selector) {
+        return systems.remove(selector);
+    }
+    function addEntity(dynamic = false) {
+        // entitiesCompnonent.set(entity, new Set())
+        const entity = entityContainer.generateEntity(dynamic);
+        return entity;
+    }
+    function entityExists(entity) {
+        return entityContainer.entityExists(entity);
+    }
+    function addDynamicEntity() {
+        return addEntity(true);
+    }
+    function removeEntity(entity) {
+        for (const [, component] of componentsDefinition) {
+            if (component.has(entity)) {
+                component.deleteFrom(entity);
+            }
+        }
+        return entityContainer.removeEntity(entity);
+    }
+    function defineComponentFromSchema(spec, componentId, constructorDefault) {
+        const prev = componentsDefinition.get(componentId);
+        if (prev) {
+            // TODO: assert spec === prev.spec
+            return prev;
+        }
+        const newComponent = defComponent(componentId, spec, constructorDefault);
+        componentsDefinition.set(componentId, newComponent);
+        return newComponent;
+    }
+    function defineComponent(spec, componentId, constructorDefault) {
+        return defineComponentFromSchema(Schemas.Map(spec), componentId, constructorDefault);
+    }
+    function getComponent(componentId) {
+        const component = componentsDefinition.get(componentId);
+        if (!component) {
+            throw new Error(`Component ${componentId} not found. You need to declare the components at the beginnig of the engine declaration`);
+        }
+        return component;
+    }
+    function* getEntitiesWith(...components) {
+        for (const [entity, ...groupComp] of getComponentDefGroup(...components)) {
+            yield [entity, ...groupComp.map((c) => c.get(entity))];
+        }
+    }
+    function* getComponentDefGroup(...args) {
+        const [firstComponentDef, ...componentDefinitions] = args;
+        for (const [entity] of firstComponentDef.iterator()) {
+            let matches = true;
+            for (const componentDef of componentDefinitions) {
+                if (!componentDef.has(entity)) {
+                    matches = false;
+                    break;
+                }
+            }
+            if (matches) {
+                yield [entity, ...args];
+            }
+        }
+    }
+    function getSystems() {
+        return systems.getSystems();
+    }
+    function removeComponentDefinition(componentId) {
+        componentsDefinition.delete(componentId);
+    }
+    return {
+        entityExists,
+        componentsDefinition,
+        addEntity,
+        addDynamicEntity,
+        removeEntity,
+        addSystem,
+        getSystems,
+        removeSystem,
+        defineComponent,
+        defineComponentFromSchema,
+        getEntitiesWith,
+        getComponent,
+        removeComponentDefinition
+    };
+}
+/**
+ * @public
+ */
+export function Engine() {
+    const engine = preEngine();
+    const crdtSystem = crdtSceneSystem(engine);
+    function update(dt) {
+        crdtSystem.receiveMessages();
+        for (const system of engine.getSystems()) {
+            const ret = system.fn(dt);
+            if (globalThis.DEBUG) {
+                if (ret && typeof ret === 'object' && typeof ret.then === 'function') {
+                    throw new Error(`A system (${system.name || 'anonymous'}) returned a thenable. Systems cannot be async functions. Documentation: https://dcl.gg/sdk/sync-systems`);
+                }
+            }
+        }
+        // TODO: Perf tip
+        // Should we add some dirtyIteratorSet at engine level so we dont have
+        // to iterate all the component definitions to get the dirty ones ?
+        const dirtySet = new Map();
+        for (const [componentId, definition] of engine.componentsDefinition) {
+            for (const entity of definition.dirtyIterator()) {
+                if (!dirtySet.has(entity)) {
+                    dirtySet.set(entity, new Set());
+                }
+                dirtySet.get(entity).add(componentId);
+            }
+        }
+        crdtSystem.createMessages(dirtySet);
+        for (const [_componentId, definition] of engine.componentsDefinition) {
+            definition.clearDirty();
+        }
+    }
+    const Transform = components.Transform(engine);
+    function* getTreeEntityArray(firstEntity, proccesedEntities) {
+        // This avoid infinite loop when there is a cyclic parenting
+        if (proccesedEntities.find((value) => firstEntity === value))
+            return;
+        proccesedEntities.push(firstEntity);
+        for (const [entity, value] of engine.getEntitiesWith(Transform)) {
+            if (value.parent === firstEntity) {
+                yield* getTreeEntityArray(entity, proccesedEntities);
+            }
+        }
+        yield firstEntity;
+    }
+    function removeEntityWithChildren(firstEntity) {
+        for (const entity of getTreeEntityArray(firstEntity, [])) {
+            engine.removeEntity(entity);
+        }
+    }
+    return {
+        addEntity: engine.addEntity,
+        addDynamicEntity: engine.addDynamicEntity,
+        removeEntity: engine.removeEntity,
+        removeEntityWithChildren,
+        addSystem: engine.addSystem,
+        removeSystem: engine.removeSystem,
+        // TODO: fix this type
+        defineComponent: engine.defineComponent,
+        defineComponentFromSchema: engine.defineComponentFromSchema,
+        getEntitiesWith: engine.getEntitiesWith,
+        getComponent: engine.getComponent,
+        removeComponentDefinition: engine.removeComponentDefinition,
+        update,
+        RootEntity: 0,
+        PlayerEntity: 1,
+        CameraEntity: 2,
+        entityExists: engine.entityExists,
+        addTransport: crdtSystem.addTransport
+    };
+}