@phalanx-engine/ecs 0.1.0

package/dist/SoAComponentStore.js

@@ -0,0 +1,253 @@
+import { TYPED_ARRAY_CONSTRUCTORS, } from './SoASchema';
+const DEFAULT_INITIAL_CAPACITY = 256;
+const GROWTH_FACTOR = 2;
+const SHRINK_THRESHOLD_SHIFT = 2;
+function setTypedArrayValue(arr, index, value) {
+    if (arr instanceof BigInt64Array) {
+        arr[index] = value;
+    }
+    else {
+        arr[index] = value;
+    }
+}
+function getTypedArrayValue(arr, index) {
+    return arr[index];
+}
+export class SoAComponentStore {
+    schema;
+    arrays;
+    _count = 0;
+    _capacity;
+    _minCapacity;
+    _autoShrink;
+    _fieldArrays = [];
+    _fieldIsBigInt = [];
+    entityToIndex = new Map();
+    indexToEntity = [];
+    _sortedEntityIds = [];
+    binarySearchInsertIndex(arr, value) {
+        let low = 0;
+        let high = arr.length;
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            if (arr[mid] < value) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        return low;
+    }
+    constructor(schema, initialCapacityOrOptions = DEFAULT_INITIAL_CAPACITY) {
+        const options = typeof initialCapacityOrOptions === 'number'
+            ? { initialCapacity: initialCapacityOrOptions }
+            : initialCapacityOrOptions;
+        const initialCapacity = Math.max(1, options.initialCapacity ?? DEFAULT_INITIAL_CAPACITY);
+        this.schema = schema;
+        this._capacity = initialCapacity;
+        this._minCapacity = initialCapacity;
+        this._autoShrink = options.autoShrink ?? false;
+        const arrays = {};
+        for (const fieldName of schema.fieldNames) {
+            const fieldType = schema.fieldTypes[fieldName];
+            const ArrayConstructor = TYPED_ARRAY_CONSTRUCTORS[fieldType];
+            arrays[fieldName] = new ArrayConstructor(initialCapacity);
+        }
+        this.arrays = arrays;
+        this.rebuildFieldCache();
+    }
+    rebuildFieldCache() {
+        const names = this.schema.fieldNames;
+        this._fieldArrays = new Array(names.length);
+        this._fieldIsBigInt = new Array(names.length);
+        for (let f = 0; f < names.length; f++) {
+            const arr = this.arrays[names[f]];
+            this._fieldArrays[f] = arr;
+            this._fieldIsBigInt[f] = arr instanceof BigInt64Array;
+        }
+    }
+    get count() {
+        return this._count;
+    }
+    get capacity() {
+        return this._capacity;
+    }
+    has(entityId) {
+        return this.entityToIndex.has(entityId);
+    }
+    indexOf(entityId) {
+        return this.entityToIndex.get(entityId) ?? -1;
+    }
+    entityAt(index) {
+        return index >= 0 && index < this._count ? this.indexToEntity[index] : -1;
+    }
+    entityIds() {
+        return this._sortedEntityIds;
+    }
+    add(entityId, values) {
+        if (this.entityToIndex.has(entityId)) {
+            throw new Error(`Entity ${entityId} already exists in SoA store`);
+        }
+        if (this._count >= this._capacity) {
+            this.grow();
+        }
+        const index = this._count++;
+        this.entityToIndex.set(entityId, index);
+        this.indexToEntity[index] = entityId;
+        const insertIdx = this.binarySearchInsertIndex(this._sortedEntityIds, entityId);
+        this._sortedEntityIds.splice(insertIdx, 0, entityId);
+        const names = this.schema.fieldNames;
+        for (let f = 0; f < this._fieldArrays.length; f++) {
+            const value = values[names[f]];
+            if (this._fieldIsBigInt[f]) {
+                this._fieldArrays[f][index] = value;
+            }
+            else {
+                this._fieldArrays[f][index] = value;
+            }
+        }
+        return index;
+    }
+    remove(entityId) {
+        const index = this.entityToIndex.get(entityId);
+        if (index === undefined) {
+            return false;
+        }
+        const lastIndex = this._count - 1;
+        if (index !== lastIndex) {
+            const lastEntityId = this.indexToEntity[lastIndex];
+            for (let f = 0; f < this._fieldArrays.length; f++) {
+                if (this._fieldIsBigInt[f]) {
+                    const arr = this._fieldArrays[f];
+                    arr[index] = arr[lastIndex];
+                }
+                else {
+                    const arr = this._fieldArrays[f];
+                    arr[index] = arr[lastIndex];
+                }
+            }
+            this.entityToIndex.set(lastEntityId, index);
+            this.indexToEntity[index] = lastEntityId;
+        }
+        this.entityToIndex.delete(entityId);
+        this.indexToEntity.length = lastIndex;
+        this._count = lastIndex;
+        const sortedIdx = this.binarySearchInsertIndex(this._sortedEntityIds, entityId);
+        if (this._sortedEntityIds[sortedIdx] === entityId) {
+            this._sortedEntityIds.splice(sortedIdx, 1);
+        }
+        this.maybeAutoShrink();
+        return true;
+    }
+    get(entityId) {
+        const index = this.entityToIndex.get(entityId);
+        if (index === undefined) {
+            return undefined;
+        }
+        const result = {};
+        for (const fieldName of this.schema.fieldNames) {
+            const arr = this.arrays[fieldName];
+            result[fieldName] = getTypedArrayValue(arr, index);
+        }
+        return result;
+    }
+    set(entityId, values) {
+        const index = this.entityToIndex.get(entityId);
+        if (index === undefined) {
+            return false;
+        }
+        for (const fieldName of this.schema.fieldNames) {
+            if (fieldName in values) {
+                const arr = this.arrays[fieldName];
+                const value = values[fieldName];
+                setTypedArrayValue(arr, index, value);
+            }
+        }
+        return true;
+    }
+    getField(entityId, fieldName) {
+        const index = this.entityToIndex.get(entityId);
+        if (index === undefined) {
+            return undefined;
+        }
+        const arr = this.arrays[fieldName];
+        return getTypedArrayValue(arr, index);
+    }
+    setField(entityId, fieldName, value) {
+        const index = this.entityToIndex.get(entityId);
+        if (index === undefined) {
+            return false;
+        }
+        const arr = this.arrays[fieldName];
+        setTypedArrayValue(arr, index, value);
+        return true;
+    }
+    clear() {
+        this._count = 0;
+        this.entityToIndex.clear();
+        this.indexToEntity.length = 0;
+        this._sortedEntityIds.length = 0;
+        for (const fieldName of this.schema.fieldNames) {
+            const arr = this.arrays[fieldName];
+            if (arr instanceof BigInt64Array) {
+                arr.fill(0n);
+            }
+            else {
+                arr.fill(0);
+            }
+        }
+    }
+    grow() {
+        const newCapacity = this._capacity * GROWTH_FACTOR;
+        this.resize(newCapacity);
+    }
+    resize(newCapacity) {
+        const copyLen = Math.min(this._count, newCapacity);
+        for (const fieldName of this.schema.fieldNames) {
+            const oldArray = this.arrays[fieldName];
+            const fieldType = this.schema.fieldTypes[fieldName];
+            const ArrayConstructor = TYPED_ARRAY_CONSTRUCTORS[fieldType];
+            const newArray = new ArrayConstructor(newCapacity);
+            if (oldArray instanceof BigInt64Array) {
+                newArray.set(oldArray.subarray(0, copyLen));
+            }
+            else {
+                newArray.set(oldArray.subarray(0, copyLen));
+            }
+            this.arrays[fieldName] = newArray;
+        }
+        this._capacity = newCapacity;
+        this.rebuildFieldCache();
+    }
+    maybeAutoShrink() {
+        if (!this._autoShrink)
+            return;
+        if (this._capacity <= this._minCapacity)
+            return;
+        if (this._count > this._capacity >>> SHRINK_THRESHOLD_SHIFT)
+            return;
+        const target = Math.max(this._minCapacity, this._count * GROWTH_FACTOR);
+        if (target < this._capacity) {
+            this.resize(target);
+        }
+    }
+    shrinkToFit(minCapacity = this._minCapacity) {
+        const target = Math.max(1, minCapacity, this._count);
+        if (target < this._capacity) {
+            this.resize(target);
+        }
+        return this._capacity;
+    }
+    forEachDense(callback) {
+        for (let i = 0; i < this._count; i++) {
+            callback(this.indexToEntity[i], i);
+        }
+    }
+    forEach(callback) {
+        for (const entityId of this._sortedEntityIds) {
+            const index = this.entityToIndex.get(entityId);
+            callback(entityId, index);
+        }
+    }
+}

package/dist/SoASchema.d.ts

@@ -0,0 +1,22 @@
+export type SoAFieldType = 'f32' | 'f64' | 'i32' | 'u32' | 'u8' | 'i64';
+export declare const TYPED_ARRAY_CONSTRUCTORS: Record<SoAFieldType, new (length: number) => TypedArrayLike>;
+export declare const FIELD_BYTE_SIZES: Record<SoAFieldType, number>;
+export type TypedArrayLike = Float32Array | Float64Array | Int32Array | Uint32Array | Uint8Array | BigInt64Array;
+export type SoASchemaDefinition = Record<string, SoAFieldType>;
+export type SoAValueType<T extends SoAFieldType> = T extends 'i64' ? bigint : number;
+export type SoAArrayType<T extends SoAFieldType> = T extends 'f32' ? Float32Array : T extends 'f64' ? Float64Array : T extends 'i32' ? Int32Array : T extends 'u32' ? Uint32Array : T extends 'u8' ? Uint8Array : T extends 'i64' ? BigInt64Array : never;
+export type SoAFieldsOf<S extends SoASchemaDefinition> = {
+    [K in keyof S]: SoAValueType<S[K]>;
+};
+export type SoAArraysOf<S extends SoASchemaDefinition> = {
+    [K in keyof S]: SoAArrayType<S[K]>;
+};
+export interface SoASchema<S extends SoASchemaDefinition = SoASchemaDefinition> {
+    readonly definition: S;
+    readonly fieldNames: (keyof S & string)[];
+    readonly fieldTypes: S;
+    readonly type: symbol;
+}
+export declare function defineSoASchema<S extends SoASchemaDefinition>(definition: S, name?: string): SoASchema<S>;
+export declare function calculateSchemaByteSize(schema: SoASchema): number;
+//# sourceMappingURL=SoASchema.d.ts.map

package/dist/SoASchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SoASchema.d.ts","sourceRoot":"","sources":["../src/SoASchema.ts"],"names":[],"mappings":"AAiCA,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,CAAC;AAKxE,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,YAAY,EAAE,KAAK,MAAM,EAAE,MAAM,KAAK,cAAc,CAOjG,CAAC;AAKF,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAOzD,CAAC;AAKF,MAAM,MAAM,cAAc,GACtB,YAAY,GACZ,YAAY,GACZ,UAAU,GACV,WAAW,GACX,UAAU,GACV,aAAa,CAAC;AAKlB,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAK/D,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,YAAY,IAC7C,CAAC,SAAS,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAKpC,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,YAAY,IAC7C,CAAC,SAAS,KAAK,GAAG,YAAY,GAC9B,CAAC,SAAS,KAAK,GAAG,YAAY,GAC9B,CAAC,SAAS,KAAK,GAAG,UAAU,GAC5B,CAAC,SAAS,KAAK,GAAG,WAAW,GAC7B,CAAC,SAAS,IAAI,GAAG,UAAU,GAC3B,CAAC,SAAS,KAAK,GAAG,aAAa,GAC/B,KAAK,CAAC;AAKR,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,mBAAmB,IAAI;KACtD,CAAC,IAAI,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACnC,CAAC;AAKF,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,mBAAmB,IAAI;KACtD,CAAC,IAAI,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACnC,CAAC;AAKF,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,mBAAmB,GAAG,mBAAmB;IAE5E,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC;IAEvB,QAAQ,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,EAAE,CAAC;IAE1C,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC;IAEvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAkBD,wBAAgB,eAAe,CAAC,CAAC,SAAS,mBAAmB,EAC3D,UAAU,EAAE,CAAC,EACb,IAAI,CAAC,EAAE,MAAM,GACZ,SAAS,CAAC,CAAC,CAAC,CASd;AAMD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAOjE"}

package/dist/SoASchema.js

@@ -0,0 +1,33 @@
+export const TYPED_ARRAY_CONSTRUCTORS = {
+    f32: Float32Array,
+    f64: Float64Array,
+    i32: Int32Array,
+    u32: Uint32Array,
+    u8: Uint8Array,
+    i64: BigInt64Array,
+};
+export const FIELD_BYTE_SIZES = {
+    f32: 4,
+    f64: 8,
+    i32: 4,
+    u32: 4,
+    u8: 1,
+    i64: 8,
+};
+export function defineSoASchema(definition, name) {
+    const fieldNames = Object.keys(definition);
+    return {
+        definition,
+        fieldNames,
+        fieldTypes: definition,
+        type: Symbol(name ?? 'SoASchema'),
+    };
+}
+export function calculateSchemaByteSize(schema) {
+    let total = 0;
+    for (const fieldName of schema.fieldNames) {
+        const fieldType = schema.fieldTypes[fieldName];
+        total += FIELD_BYTE_SIZES[fieldType];
+    }
+    return total;
+}

package/dist/SystemContext.d.ts

@@ -0,0 +1,18 @@
+import type { EventBus } from './EventBus';
+import type { EntityManager } from './EntityManager';
+import type { GameSystem } from './GameSystem';
+import type { IAbilitySystem } from './IAbilitySystem';
+import type { IPhysicsWorld } from './IPhysicsWorld';
+import type { PoolManager } from './pool/PoolManager';
+export declare class SystemContext {
+    readonly eventBus: EventBus;
+    readonly entityManager: EntityManager;
+    private systemRegistry;
+    abilities: IAbilitySystem | undefined;
+    physics: IPhysicsWorld | undefined;
+    pools: PoolManager | null;
+    constructor(eventBus: EventBus, entityManager: EntityManager);
+    registerSystem(system: GameSystem): void;
+    getSystem<T extends GameSystem>(systemClass: new (...args: any[]) => T): T | undefined;
+}
+//# sourceMappingURL=SystemContext.d.ts.map

package/dist/SystemContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SystemContext.d.ts","sourceRoot":"","sources":["../src/SystemContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAoBtD,qBAAa,aAAa;IAExB,SAAgB,QAAQ,EAAE,QAAQ,CAAC;IAGnC,SAAgB,aAAa,EAAE,aAAa,CAAC;IAG7C,OAAO,CAAC,cAAc,CAAwC;IAQvD,SAAS,EAAE,cAAc,GAAG,SAAS,CAAa;IAQlD,OAAO,EAAE,aAAa,GAAG,SAAS,CAAa;IAO/C,KAAK,EAAE,WAAW,GAAG,IAAI,CAAQ;gBAGtC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,aAAa;IAUvB,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAWxC,SAAS,CAAC,CAAC,SAAS,UAAU,EAAE,WAAW,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,SAAS;CAG9F"}

package/dist/SystemContext.js

@@ -0,0 +1,18 @@
+export class SystemContext {
+    eventBus;
+    entityManager;
+    systemRegistry = new Map();
+    abilities = undefined;
+    physics = undefined;
+    pools = null;
+    constructor(eventBus, entityManager) {
+        this.eventBus = eventBus;
+        this.entityManager = entityManager;
+    }
+    registerSystem(system) {
+        this.systemRegistry.set(system.constructor, system);
+    }
+    getSystem(systemClass) {
+        return this.systemRegistry.get(systemClass);
+    }
+}

package/dist/SystemRegistry.d.ts

@@ -0,0 +1,20 @@
+import { EntityManager } from './EntityManager';
+import { EventBus } from './EventBus';
+import { SystemContext } from './SystemContext';
+import type { GameSystem } from './GameSystem';
+export declare class SystemRegistry {
+    readonly eventBus: EventBus;
+    readonly entityManager: EntityManager;
+    private readonly context;
+    private tickSystems;
+    private frameSystems;
+    constructor(componentTypes?: symbol[]);
+    registerSystems(tickSystems: GameSystem[], frameSystems: GameSystem[]): void;
+    getAllSystems(): Set<GameSystem>;
+    addFrameSystem(system: GameSystem): void;
+    processAllTicks(tick: number): void;
+    updateAll(deltaTime: number): void;
+    getContext(): SystemContext;
+    dispose(): void;
+}
+//# sourceMappingURL=SystemRegistry.d.ts.map

package/dist/SystemRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SystemRegistry.d.ts","sourceRoot":"","sources":["../src/SystemRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAU/C,qBAAa,cAAc;IAEzB,SAAgB,QAAQ,EAAE,QAAQ,CAAC;IACnC,SAAgB,aAAa,EAAE,aAAa,CAAC;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IAMxC,OAAO,CAAC,WAAW,CAAoB;IAKvC,OAAO,CAAC,YAAY,CAAoB;gBAE5B,cAAc,CAAC,EAAE,MAAM,EAAE;IAwB9B,eAAe,CACpB,WAAW,EAAE,UAAU,EAAE,EACzB,YAAY,EAAE,UAAU,EAAE,GACzB,IAAI;IAoCA,aAAa,IAAI,GAAG,CAAC,UAAU,CAAC;IAShC,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAWxC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAanC,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAWlC,UAAU,IAAI,aAAa;IAO3B,OAAO,IAAI,IAAI;CAevB"}

package/dist/SystemRegistry.js

@@ -0,0 +1,73 @@
+import { EntityManager } from './EntityManager';
+import { EventBus } from './EventBus';
+import { SystemContext } from './SystemContext';
+export class SystemRegistry {
+    eventBus;
+    entityManager;
+    context;
+    tickSystems = [];
+    frameSystems = [];
+    constructor(componentTypes) {
+        this.eventBus = new EventBus();
+        this.entityManager = new EntityManager();
+        if (componentTypes) {
+            this.entityManager.registerComponentTypes(componentTypes);
+        }
+        this.context = new SystemContext(this.eventBus, this.entityManager);
+    }
+    registerSystems(tickSystems, frameSystems) {
+        this.tickSystems = tickSystems;
+        this.frameSystems = frameSystems;
+        const allSystems = new Set([...tickSystems, ...frameSystems]);
+        for (const system of allSystems) {
+            this.context.registerSystem(system);
+        }
+        if (this.context.abilities) {
+            for (const system of this.context.abilities.tickSystems) {
+                if (this.tickSystems.includes(system)) {
+                    continue;
+                }
+                this.tickSystems.push(system);
+                this.context.registerSystem(system);
+            }
+        }
+        const toInit = new Set([...this.tickSystems, ...this.frameSystems]);
+        for (const system of toInit) {
+            system.init(this.context);
+        }
+    }
+    getAllSystems() {
+        return new Set([...this.tickSystems, ...this.frameSystems]);
+    }
+    addFrameSystem(system) {
+        this.frameSystems.push(system);
+        this.context.registerSystem(system);
+    }
+    processAllTicks(tick) {
+        for (const system of this.tickSystems) {
+            if (system.enabled) {
+                system.processTick(tick);
+            }
+        }
+    }
+    updateAll(deltaTime) {
+        for (const system of this.frameSystems) {
+            if (system.enabled) {
+                system.update(deltaTime);
+            }
+        }
+    }
+    getContext() {
+        return this.context;
+    }
+    dispose() {
+        for (let i = this.tickSystems.length - 1; i >= 0; i--) {
+            this.tickSystems[i].dispose();
+        }
+        for (let i = this.frameSystems.length - 1; i >= 0; i--) {
+            this.frameSystems[i].dispose();
+        }
+        this.eventBus?.clearAll();
+        this.entityManager?.clear();
+    }
+}

package/dist/TickFrameManager.d.ts

@@ -0,0 +1,35 @@
+import type { ITickFrameProvider, TickHandler, FrameHandler, Unsubscribe, PauseHandler } from './ITickFrameProvider';
+export interface TickFrameManagerConfig {
+    tickRate?: number;
+    maxFrameTime?: number;
+}
+export declare class TickFrameManager implements ITickFrameProvider {
+    private tickRate;
+    private tickDuration;
+    private maxFrameTime;
+    private tickCallbacks;
+    private frameCallbacks;
+    private pauseHandlers;
+    private resumeHandlers;
+    private currentTick;
+    private accumulator;
+    private lastTime;
+    private isRunning;
+    private _isPaused;
+    private rafId;
+    constructor(config?: TickFrameManagerConfig);
+    onTick(callback: TickHandler): Unsubscribe;
+    onFrame(callback: FrameHandler): Unsubscribe;
+    start(): void;
+    stop(): void;
+    private loop;
+    requestPause(): void;
+    requestResume(): void;
+    onPause(handler: PauseHandler): Unsubscribe;
+    onResume(handler: PauseHandler): Unsubscribe;
+    getCurrentTick(): number;
+    getTickRate(): number;
+    isActive(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=TickFrameManager.d.ts.map

package/dist/TickFrameManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TickFrameManager.d.ts","sourceRoot":"","sources":["../src/TickFrameManager.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,kBAAkB,EAClB,WAAW,EACX,YAAY,EACZ,WAAW,EAEX,YAAY,EACb,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,sBAAsB;IAErC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,gBAAiB,YAAW,kBAAkB;IACzD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,YAAY,CAAS;IAE7B,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,cAAc,CAAsB;IAE5C,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,KAAK,CAAuB;gBAExB,MAAM,CAAC,EAAE,sBAAsB;IAYpC,MAAM,CAAC,QAAQ,EAAE,WAAW,GAAG,WAAW;IAe1C,OAAO,CAAC,QAAQ,EAAE,YAAY,GAAG,WAAW;IAa5C,KAAK,IAAI,IAAI;IAgBb,IAAI,IAAI,IAAI;IAYnB,OAAO,CAAC,IAAI,CA2CV;IAOK,YAAY,IAAI,IAAI;IAUpB,aAAa,IAAI,IAAI;IAUrB,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,WAAW;IAW3C,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,WAAW;IAW5C,cAAc,IAAI,MAAM;IAOxB,WAAW,IAAI,MAAM;IAOrB,QAAQ,IAAI,OAAO;IAOnB,OAAO,IAAI,IAAI;CAOvB"}

package/dist/TickFrameManager.js

@@ -0,0 +1,130 @@
+export class TickFrameManager {
+    tickRate;
+    tickDuration;
+    maxFrameTime;
+    tickCallbacks = [];
+    frameCallbacks = [];
+    pauseHandlers = [];
+    resumeHandlers = [];
+    currentTick = 0;
+    accumulator = 0;
+    lastTime = 0;
+    isRunning = false;
+    _isPaused = false;
+    rafId = null;
+    constructor(config) {
+        this.tickRate = config?.tickRate ?? 60;
+        this.tickDuration = 1.0 / this.tickRate;
+        this.maxFrameTime = config?.maxFrameTime ?? 0.25;
+    }
+    onTick(callback) {
+        this.tickCallbacks.push(callback);
+        return () => {
+            const index = this.tickCallbacks.indexOf(callback);
+            if (index !== -1) {
+                this.tickCallbacks.splice(index, 1);
+            }
+        };
+    }
+    onFrame(callback) {
+        this.frameCallbacks.push(callback);
+        return () => {
+            const index = this.frameCallbacks.indexOf(callback);
+            if (index !== -1) {
+                this.frameCallbacks.splice(index, 1);
+            }
+        };
+    }
+    start() {
+        if (this.isRunning) {
+            console.warn('[TickFrameManager] Already running');
+            return;
+        }
+        this.isRunning = true;
+        this.lastTime = performance.now() / 1000;
+        this.accumulator = 0;
+        this.loop();
+    }
+    stop() {
+        this.isRunning = false;
+        if (this.rafId !== null) {
+            cancelAnimationFrame(this.rafId);
+            this.rafId = null;
+        }
+    }
+    loop = () => {
+        if (!this.isRunning)
+            return;
+        const currentTime = performance.now() / 1000;
+        let frameTime = currentTime - this.lastTime;
+        this.lastTime = currentTime;
+        if (frameTime > this.maxFrameTime) {
+            frameTime = this.maxFrameTime;
+        }
+        this.accumulator += frameTime;
+        while (this.accumulator >= this.tickDuration) {
+            const emptyBatch = {
+                tick: this.currentTick,
+                commands: {},
+            };
+            for (const callback of this.tickCallbacks) {
+                callback(this.currentTick, emptyBatch);
+            }
+            this.currentTick++;
+            this.accumulator -= this.tickDuration;
+        }
+        const alpha = this.accumulator / this.tickDuration;
+        for (const callback of this.frameCallbacks) {
+            callback(alpha, frameTime);
+        }
+        this.rafId = requestAnimationFrame(this.loop);
+    };
+    requestPause() {
+        if (this._isPaused)
+            return;
+        this._isPaused = true;
+        this.stop();
+        for (const handler of this.pauseHandlers)
+            handler();
+    }
+    requestResume() {
+        if (!this._isPaused)
+            return;
+        this._isPaused = false;
+        this.start();
+        for (const handler of this.resumeHandlers)
+            handler();
+    }
+    onPause(handler) {
+        this.pauseHandlers.push(handler);
+        return () => {
+            const idx = this.pauseHandlers.indexOf(handler);
+            if (idx !== -1)
+                this.pauseHandlers.splice(idx, 1);
+        };
+    }
+    onResume(handler) {
+        this.resumeHandlers.push(handler);
+        return () => {
+            const idx = this.resumeHandlers.indexOf(handler);
+            if (idx !== -1)
+                this.resumeHandlers.splice(idx, 1);
+        };
+    }
+    getCurrentTick() {
+        return this.currentTick;
+    }
+    getTickRate() {
+        return this.tickRate;
+    }
+    isActive() {
+        return this.isRunning;
+    }
+    dispose() {
+        this.stop();
+        this.tickCallbacks = [];
+        this.frameCallbacks = [];
+        this.pauseHandlers = [];
+        this.resumeHandlers = [];
+    }
+}

package/dist/debug/DebugDataProvider.d.ts

@@ -0,0 +1,26 @@
+import type { EntityManager } from '../EntityManager';
+import type { PoolManager } from '../pool/PoolManager';
+import type { DebugSnapshot, DebugDataProviderConfig } from './types';
+type SnapshotCallback = (snapshot: DebugSnapshot) => void;
+export declare class DebugDataProvider {
+    private readonly entityManager;
+    private readonly pools;
+    private readonly updateInterval;
+    private subscribers;
+    private intervalId;
+    private _paused;
+    set paused(value: boolean);
+    constructor(entityManager: EntityManager, pools: PoolManager | null, config?: DebugDataProviderConfig);
+    subscribe(callback: SnapshotCallback): () => void;
+    getSnapshot(): DebugSnapshot;
+    start(): void;
+    stop(): void;
+    dispose(): void;
+    private push;
+    private collectSnapshot;
+    private collectEntities;
+    private collectSoAStores;
+    private collectPools;
+}
+export {};
+//# sourceMappingURL=DebugDataProvider.d.ts.map

package/dist/debug/DebugDataProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DebugDataProvider.d.ts","sourceRoot":"","sources":["../../src/debug/DebugDataProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,OAAO,KAAK,EACV,aAAa,EAKb,uBAAuB,EACxB,MAAM,SAAS,CAAC;AAKjB,KAAK,gBAAgB,GAAG,CAAC,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAC;AAyB1D,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAC3C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IAExC,OAAO,CAAC,WAAW,CAAoC;IACvD,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,OAAO,CAAkB;IAGjC,IAAW,MAAM,CAAC,KAAK,EAAE,OAAO,EAE/B;gBAGC,aAAa,EAAE,aAAa,EAC5B,KAAK,EAAE,WAAW,GAAG,IAAI,EACzB,MAAM,CAAC,EAAE,uBAAuB;IAa3B,SAAS,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,IAAI;IAYjD,WAAW,IAAI,aAAa;IAU5B,KAAK,IAAI,IAAI;IAYb,IAAI,IAAI,IAAI;IAUZ,OAAO,IAAI,IAAI;IAOtB,OAAO,CAAC,IAAI;IAQZ,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,eAAe;IAgCvB,OAAO,CAAC,gBAAgB;IA6BxB,OAAO,CAAC,YAAY;CAYrB"}