@draug/engine 1.0.0

package/README.md

@@ -0,0 +1 @@
+# engine

package/ecs/command.ts

@@ -0,0 +1,44 @@
+import type { ComponentType } from "./components";
+import { World } from "./world";
+
+export type WorldCommand = (world: World) => void;
+export type ComponentInitFn<C extends ComponentType> =
+    (component: InstanceType<C>) => void;
+
+export type CreateEntityComponentEntry<T extends ComponentType = ComponentType> =
+    T extends unknown ? [T, ComponentInitFn<T>] : never;
+
+export function entry<T extends ComponentType>(
+    component: T,
+    init: ComponentInitFn<T> = () => { }
+): CreateEntityComponentEntry {
+    return [component, init as ComponentInitFn<ComponentType>];
+}
+
+export class Commands {
+    private readonly commandsQueue_: WorldCommand[] = [];
+
+    constructor(
+        private readonly world: World
+    ) { }
+
+    public add(cmd: WorldCommand): void {
+        this.commandsQueue_.push(cmd);
+    };
+    public flush(world: World): void {
+        for (const cmd of this.commandsQueue_)
+            cmd(world);
+        this.commandsQueue_.length = 0;
+    }
+    public createEntity(...entries: CreateEntityComponentEntry[]): number {
+        const id = this.world.entities.create();
+
+        const cmd = (world: World) => {
+            for (const [cls, initFn] of entries) {
+                world.addComponent(id, cls, initFn);
+            }
+        }
+        this.add(cmd);
+        return id;
+    }
+};

package/ecs/components/component-storage.ts

@@ -0,0 +1,86 @@
+import { ObjectPool } from "@draug/core/memory/pool";
+import { Bitmap } from "bitmap-index";
+import { SparseSet } from "ts-sparse-set";
+import { ECS_DEFAULTS } from "../constant";
+import type { IStorage } from "./types";
+import type { ClassType } from "@draug/types/class";
+
+export class ComponentStorage
+    // Only pointer-types.
+    <T extends object> implements IStorage<T> {
+    private bits_: Bitmap;
+    private set_: SparseSet<T>;
+    private pool_: ObjectPool<T>;
+    private id_: number = 0;
+    private cls: ClassType<T>
+
+    constructor(cap = ECS_DEFAULTS.MAX_ENTITY_COUNT, factory: () => T, cls: ClassType<T>) {
+        this.set_ = new SparseSet(cap);
+        this.bits_ = new Bitmap(cap);
+        this.pool_ = new ObjectPool(factory, cap);
+        this.cls = cls;
+    }
+    public bitmap(): Bitmap {
+        return this.bits_;
+    }
+
+    public get id(): number {
+        return this.id_;
+    }
+
+    public _internalSetId(id: number): number {
+        return this.id_ = id;
+    }
+
+    public add(id: number, initFn?: (obj: T) => T): T {
+        const obj = this.pool_.acquire();
+        initFn?.(obj);
+        const value = this.set_.add(id, obj);
+        this.bits_.set(id);
+        return value;
+    }
+
+    public remove(id: number): void {
+        const obj = this.set_.get(id);
+        if (!obj) return;
+        this.bits_.remove(id);
+        this.pool_.release(obj);
+        this.set_.remove(id);
+    }
+
+    public get(id: number): T | null {
+        return this.set_.get(id);
+    }
+
+    public tryGet(id: number): T {
+        const x = this.set_.get(id);
+        if (!x)
+            throw new Error(`[ComponentStorage "${this.cls.name}"]: Requesting non-existing item with ID ${id}.`);
+        return x;
+    }
+
+    public writeComponentsToBuf(ids: ReadonlyArray<number>, out: T[]): number {
+        let len = 0;
+        for (const id of ids) {
+            const obj = this.set_.get(id);
+            if (obj !== null) out[len++] = obj;
+        }
+        return len;
+    }
+
+    public has(id: number): boolean {
+        return this.bits_.contains(id);
+    }
+
+    public entityIds(): number[] {
+        return Array.from(this.bits_);
+    }
+
+    public size(): number {
+        return this.bits_.count();
+    }
+
+    public forEach(cb: (id: number) => void): void {
+        this.bits_.range(x => cb(x));
+    }
+};

package/ecs/components/index.ts

@@ -0,0 +1,12 @@
+export type {
+    ComponentType,
+    IStorage,
+} from './types'
+export {
+    ComponentsManager,
+    ComponentAlreadyRegisteredError,
+    ComponentStorageType,
+} from './manager'
+export { Component, getComponentId } from './utils'
+export { ComponentStorage } from './component-storage'
+export { SingletonStorage } from './singleton-storage'

package/ecs/components/manager.ts

@@ -0,0 +1,91 @@
+import { UnregisteredComponentStorageError } from "../entity";
+import { ECS_DEFAULTS } from "../constant";
+import { ComponentStorage } from "./component-storage";
+import type { ComponentType, IStorage } from "./types";
+import { SingletonStorage } from "./singleton-storage";
+import { getComponentId } from "./";
+
+export enum ComponentStorageType {
+    COMPONENT_STORAGE = 1,
+    SINGLETON_STORAGE = 2,
+};
+
+type RegisterSingletoneComponentOptions<T extends object> = {
+    storageType: ComponentStorageType.SINGLETON_STORAGE;
+    factory: () => T;
+}
+type RegisterComponentStorageOptions<T extends object> = {
+    storageType: ComponentStorageType.COMPONENT_STORAGE;
+    factory?: () => T;
+}
+
+type RegisterComponentOptions<T extends object> = RegisterSingletoneComponentOptions<T> | RegisterComponentStorageOptions<T>
+
+export class ComponentAlreadyRegisteredError extends Error {
+    constructor(component: ComponentType) {
+        super(`Component ${component.name} already registered!`)
+    }
+}
+
+export class ComponentsManager {
+    private readonly storages_ = new Map<ComponentType, IStorage<any>>();
+    private currId_ = 0;
+    private nextId(): number {
+        return ++this.currId_;
+    }
+
+    constructor(
+        private maxEntityCount: number = ECS_DEFAULTS.MAX_ENTITY_COUNT
+    ) { }
+
+    public register<T extends object>(
+        component: ComponentType<T>,
+        opts?: RegisterComponentOptions<T>
+    ): IStorage<T> {
+        if (this.storages_.has(component))
+            return this.storages_.get(component)!;
+
+        let store: IStorage<T>;
+
+        switch (opts?.storageType) {
+            case ComponentStorageType.SINGLETON_STORAGE:
+                store = this.createSingletonStore(opts);
+                break;
+            case ComponentStorageType.COMPONENT_STORAGE:
+                store = this.createComponentStore(component, opts);
+                break;
+            default: 
+                store = this.createComponentStore(component, opts);
+                break;
+        }
+
+        this.storages_.set(component, store);
+        return store;
+    }
+
+    private createComponentStore<T extends object>(component: ComponentType<T>, opts?: RegisterComponentOptions<T>): IStorage<T> {
+        const factory = opts?.factory ?? ((...args: any[]) => new component(...args));
+        const store = new ComponentStorage(this.maxEntityCount, factory, component);
+        store._internalSetId(this.nextId());
+        return store;
+    }
+
+    private createSingletonStore<T extends object>(opts?: RegisterSingletoneComponentOptions<T>): IStorage<T> {
+        if(!opts?.factory) {
+            throw new Error("For singletone storage provide factory is required!")
+        }
+        return new SingletonStorage(opts.factory);
+    }
+
+    public getStorage<T extends object>(component: ComponentType<T>): IStorage<T> {
+        const store = this.storages_.get(component);
+        if (store === undefined)
+            throw new UnregisteredComponentStorageError(component);
+
+        return store;
+    }
+
+    public getComponentId(ctor: ComponentType): number {
+        return getComponentId(ctor);
+    }
+}

package/ecs/components/singleton-storage.ts

@@ -0,0 +1,51 @@
+import type { Bitmap } from "bitmap-index";
+import type { IStorage } from "./types";
+
+export class SingletonStorage<T extends object> implements IStorage<T> {
+    private value: T | null = null;
+    private entityId: number | null = null;
+    constructor(private factory: () => T) { }
+    bitmap(): Bitmap {
+        throw new Error("Singletone component cannot has a bitmap!");
+    }
+
+    public add(id: number, initFn?: ((obj: T) => T) | undefined): T {
+        if (this.value !== null)
+            throw new Error("Singleton already initiated");
+
+        this.entityId = id;
+        this.value = this.factory();
+        initFn?.(this.value);
+        return this.value;
+
+    }
+    public remove(id: number): void {
+        if (!this.validateId(id))
+            return;
+        this.value = null;
+        this.entityId = null;
+    }
+    public get(id: number): T | null {
+        if (!this.validateId(id))
+            return null;
+        return this.value;
+    }
+    public tryGet(id: number): T {
+        if (!this.validateId(id))
+            throw new Error("[SingletoneStorage]: ID missmatch.");
+        return this.value!;
+    }
+    public has(id: number): boolean {
+        return this.validateId(id);
+    }
+    public size(): number {
+        return this.value !== null ? 1 : 0;
+    }
+    public forEach(cb: (id: number) => void): void {
+        if(this.entityId !== null) 
+            cb(this.entityId);
+    }
+    private validateId(id: number): boolean {
+        return this.entityId !== null && id === this.entityId;
+    }
+}

package/ecs/components/types.ts

@@ -0,0 +1,14 @@
+import type { ClassType } from "@draug/types/class";
+import type { Bitmap } from "bitmap-index";
+
+export type ComponentType<T extends object = object> = ClassType<T>;
+export interface IStorage <T extends object> {
+    add(id: number, initFn?: (obj: T) => T): T;
+    remove(id: number): void;
+    get(id: number): T | null;
+    tryGet(id: number): T;
+    has(id: number): boolean
+    size(): number;
+    forEach(cb: (id: number) => void): void;
+    bitmap(): Bitmap;
+}; 

package/ecs/components/utils.ts

@@ -0,0 +1,18 @@
+const registry = new Map<Function, number>();
+let id = 0;
+
+export function Component(): ClassDecorator {
+    return (target: Function) => {
+        if (registry.has(target)) return;
+
+        registry.set(target, ++id);
+    }
+};
+
+export function getComponentId(ctor: Function): number {
+    const id = registry.get(ctor);
+    if (id === undefined) {
+        throw new Error(`Component not registered: ${ctor.name}`);
+    }
+    return id;
+}

package/ecs/constant.ts

@@ -0,0 +1,3 @@
+export const ECS_DEFAULTS = {
+    MAX_ENTITY_COUNT: Math.pow(2, 16),
+} as const;

package/ecs/entity.ts

@@ -0,0 +1,44 @@
+import type { ComponentType } from "./components";
+import { World } from "./world";
+
+export type EntityID = number;
+
+export class UnregisteredComponentStorageError extends Error {
+    constructor(component: ComponentType) {
+        super(`Cannot get storage for component ${component.name}. Seems like it's not registered in world.`);
+    }
+}
+
+export class EntityMaskNotFoundError extends Error {
+    constructor(id: EntityID) {
+        super(`Cannot find bitmask for entity [${id}]. Seems like it's not registered in the EntityManager.`)
+    }
+}
+
+export class EntitiesManager {
+    private id_: EntityID = 0;
+    private nextId(): EntityID {
+        return ++this.id_;
+    }
+
+    public create(): EntityID {
+        return this.nextId();
+    }
+};
+
+export class EntityRef {
+    constructor(
+        private world: World,
+        public id: EntityID,
+    ) { }
+
+    public with<
+        T extends ComponentType[],
+        Result extends { [K in keyof T]: InstanceType<T[K]> }
+    >(...components: T): Result {
+        return components.map(c => {
+            const s = this.world.components.getStorage(c);
+            return s.tryGet(this.id);
+        }) as Result;
+    };
+}

package/ecs/events-buffer.ts

@@ -0,0 +1,62 @@
+export class EventBuffer<T extends unknown> {
+    private readBuf: T[] = [];
+    private writeBuf: T[] = [];
+    public write(event: T): void {
+        this.writeBuf.push(event);
+    };
+
+    /**
+     * Advances the buffer to the next frame.
+     *
+     * Performs a double-buffer flip:
+     * - Promotes all events written during the previous frame (`writeBuf`)
+     *   to be readable in the current frame (`readBuf`).
+     * - Reuses the previous `readBuf` as the new `writeBuf` and clears it
+     *   to collect events for the next frame.
+     *
+     * After calling this method:
+     * - `get()` will return a stable snapshot of events produced in the previous frame.
+     * - `add()` will write into an empty buffer for the current frame.
+     *
+     * Guarantees:
+     * - No events written during the current frame are visible until the next `swap()`.
+     * - Readers observe a consistent, immutable snapshot within a frame.
+     *
+     * Expected to be called exactly once per frame, before system execution.
+    */
+    public swap() {
+        const tmp = this.readBuf;
+        this.readBuf = this.writeBuf;
+        this.writeBuf = tmp;
+        this.writeBuf.length = 0;
+    }
+
+    public read(): ReadonlyArray<T> {
+        return this.readBuf;
+    };
+    public size(): number {
+        return this.readBuf.length;
+    }
+};
+
+type EventKey<T> = symbol & { __type?: T };
+
+export function createEventKey<T>(description?: string): EventKey<T> {
+    return Symbol(description) as EventKey<T>;
+}
+
+export class EventBus {
+    private storage: Map<symbol, EventBuffer<any>> = new Map();
+    public swapAll(): void {
+        this.storage.forEach(s => s.swap());
+    }
+
+    public getBuffer<T>(key: EventKey<T>): EventBuffer<T> {
+        let buf = this.storage.get(key);
+        if (!buf) {
+            buf = new EventBuffer<T>();
+            this.storage.set(key, buf);
+        }
+        return buf;
+    }
+}

package/ecs/query.ts

@@ -0,0 +1,169 @@
+import type { ComponentType } from "./components";
+import type { EntityID } from "./entity";
+import type { World } from "./world";
+import { Bitmap } from "bitmap-index";
+
+export type QueryParameters = {
+    include?: ComponentType[];
+    exclude?: ComponentType[];
+    anyOf?: ComponentType[];
+    excludeEntitiesIds?: number[];
+    filter?: (id: number) => boolean;
+};
+
+type CachedQuery = {
+    params: QueryParameters;
+    bitmap: Bitmap;
+    dirty: boolean;
+    deps: Set<ComponentType>;
+};
+
+export class QueryManager {
+    private cache = new Map<string, CachedQuery>();
+
+    constructor(
+        private readonly world: World,
+    ) { }
+
+    public get(params: QueryParameters): EntityID[] {
+        const key = this.getKey(params);
+        let entry = this.cache.get(key);
+
+        if (!entry) {
+            entry = {
+                params,
+                bitmap: this.compute(params),
+                dirty: false,
+                deps: this.collectDeps(params),
+            };
+            this.cache.set(key, entry);
+        }
+
+        if (entry.dirty) {
+            entry.bitmap = this.compute(entry.params);
+            entry.dirty = false;
+        }
+
+        // 1. Динамически применяем исключение конкретных ID 
+        let targetBitmap = entry.bitmap;
+        if (params.excludeEntitiesIds?.length) {
+            targetBitmap = entry.bitmap.clone(); 
+            const excludeBm = new Bitmap();
+            for (const id of params.excludeEntitiesIds) {
+                excludeBm.set(id);
+            }
+            targetBitmap.andNot(excludeBm);
+        }
+
+        // 2. Динамически применяем фильтр
+        if (params.filter) {
+            const result: number[] = [];
+            targetBitmap.range(id => {
+                if (params.filter!(id)) result.push(id);
+            });
+            return result;
+        }
+
+        return this.extractIds(targetBitmap);
+    }
+
+    public invalidate(component: ComponentType): void {
+        for (const entry of this.cache.values()) {
+            if (entry.deps.has(component)) {
+                entry.dirty = true;
+            }
+        }
+    }
+
+    private getKey(q: QueryParameters): string {
+        return [
+            this.ids(q.include),
+            this.ids(q.exclude),
+            this.ids(q.anyOf),
+        ].join("|");
+    }
+
+    private ids(arr?: ComponentType[]): string {
+        if (!arr || arr.length === 0) return "";
+        return arr
+            .map(c => this.world.components.getComponentId(c))
+            .sort((a, b) => a - b)
+            .join(",");
+    }
+
+    private collectDeps(q: QueryParameters): Set<ComponentType> {
+        const set = new Set<ComponentType>();
+        q.include?.forEach(c => set.add(c));
+        q.exclude?.forEach(c => set.add(c));
+        q.anyOf?.forEach(c => set.add(c));
+        return set;
+    }
+
+    private compute(params: QueryParameters): Bitmap {
+        let result = this.combineBitmaps(params.include, 'and');
+
+        const any = this.combineBitmaps(params.anyOf, 'or');
+        if (any) {
+            result = result ? result.and(any) : any;
+        }
+
+        if (!result) {
+            return new Bitmap();
+        }
+
+        this.applyExclusions(result, params.exclude);
+        return result;
+    }
+
+    private combineBitmaps(
+        components: ComponentType[] | undefined,
+        op: 'and' | 'or'
+    ): Bitmap | null {
+        if (!components?.length) return null;
+
+        let result: Bitmap | null = null;
+        let hasAtLeastOneValid = false;
+
+        for (const c of components) {
+            const bm = this.world.components.getStorage(c)?.bitmap();
+
+            if (!bm) {
+                if (op === 'and') {
+                    return new Bitmap();
+                }
+                continue;
+            }
+
+            hasAtLeastOneValid = true;
+            if (!result) {
+                result = bm.clone();
+            } else {
+                op === 'and' ? result.and(bm) : result.or(bm);
+            }
+        }
+
+        if (op === 'or' && !hasAtLeastOneValid) {
+            return new Bitmap();
+        }
+
+        return result;
+    }
+
+    private applyExclusions(
+        target: Bitmap,
+        excludeComponents?: ComponentType[],
+    ): void {
+        if (excludeComponents?.length) {
+            for (const c of excludeComponents) {
+                const bm = this.world.components.getStorage(c)?.bitmap();
+                if (bm) target.andNot(bm);
+            }
+        }
+    }
+
+    private extractIds(bitmap: Bitmap): number[] {
+        const result: number[] = [];
+        bitmap.range(id => { result.push(id) });
+        return result;
+    }
+}

package/ecs/resources/index.ts

@@ -0,0 +1 @@
+export { ResourcesManager } from './resources'

package/ecs/resources/resources.ts

@@ -0,0 +1,28 @@
+import type { ClassType } from "@draug/types/class";
+
+export class ResourcesManager {
+    private readonly items_ = new Map<ClassType<any>, unknown>();
+    public insert<T extends object>(type: ClassType<T>, value: T): T {
+        this.items_.set(type, value);
+        return value;
+    };
+    public get<T extends object>(type: ClassType<T>): T {
+        const value = this.items_.get(type);
+        if (!value)
+            throw new Error(`Resource of class ${type.name} does not exist!`);
+
+        return value as T;
+    }
+    public getOrInsert<T extends object>(type: ClassType<T>, factory: () => T): T {
+        let value: T | null = (this.items_.get(type) ?? null) as T | null;
+        if (value === null) {
+            value = factory();
+            this.items_.set(type, value);
+        }
+
+        return value;
+    }
+    public remove<T>(type: ClassType<T>): void {
+        this.items_.delete(type);
+    }
+};