@draug/engine 1.0.0 → 1.0.2

package/ecs/query.ts

@@ -1,169 +0,0 @@
-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

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

package/ecs/resources/resources.ts

@@ -1,28 +0,0 @@
-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);
-    }
-};

package/ecs/system.ts

@@ -1,214 +0,0 @@
-import { DAGNode, topologicalSort } from '@draug/core/graph/dag';
-import type { ClassType, ComponentType } from '@draug/types/class'
-import type { World } from "./world";
-import type { QueryParameters } from './query';
-
-
-export class SystemError extends Error {
-    constructor(target: Function) {
-        super(`[System Error] (System "${target.name}".`)
-    }
-}
-export class ErrNotASystem extends Error {
-    constructor(target: Function) {
-        super(`Provided class "${target.name}" is not a System! Extend your class from SystemBase.`)
-    }
-}
-export class ErrMissingSystemMetadata extends SystemError {
-    constructor(target: SystemCtor) {
-        super(target);
-        this.message = `${this.message}: Missing system metadata! Define system class with @System decorator.`
-    }
-};
-
-export type SystemMetadata = {
-    /**
-     * ECS query definition used to select entities for this system execution.
-     *
-     * Determines the iteration set passed to {@link SystemBase.compute}.
-     * The ECS runtime resolves entities based on this query each update.
-     */
-    query: Readonly<QueryParameters>;
-    /**
-     * Explicit list of component types required by the system but not necessarily
-     * part of the iteration query.
-     *
-     * Used for:
-     * - ensuring component storages are initialized in the world
-     * - safe access via `world.components.getStorage`
-     * - dependencies that should not affect entity selection
-     *
-     * This does NOT influence entity iteration; only runtime validation/setup.
-     */
-    requiredComponents: Set<ComponentType>;
-    /**
-     * Systems that must run before this one. Pass constructor arguments
-     * `super(OtherSystemCtor, ...)` to add edges; each listed system is scheduled earlier than
-     * this instance. Used when {@link SystemsManager.build} computes a topological execution order.
-     */
-    computeAfter?: Set<SystemCtor>;
-};
-export type SystemDecoratorProps = {
-    query: SystemMetadata['query'];
-    requiredComponents?: ComponentType[];
-    computeAfter?: SystemCtor[];
-};
-const SystemMetadataSymbol = Symbol("system");
-type FunctionWithMetadata = Function & { [SystemMetadataSymbol]?: SystemMetadata };
-
-export function System(props: SystemDecoratorProps): ClassDecorator {
-    return (target: Function) => {
-        const systemTarget = target as FunctionWithMetadata;
-
-        if ('__proto__' in systemTarget && systemTarget.__proto__ !== SystemBase) {
-            throw new ErrNotASystem(target);
-        }
-
-        const query = { ...props.query };
-        const requiredComponents = new Set(props.requiredComponents);
-        const computeAfter = new Set(props.computeAfter);
-        const metadata: SystemMetadata = { query, requiredComponents, computeAfter };
-
-        // Теперь TS позволяет записать значение
-        systemTarget[SystemMetadataSymbol] = metadata;
-    };
-}
-
-export function getSystemMetadata(system: SystemCtor): SystemMetadata {
-    if (hasMetadata(system)) {
-        return system[SystemMetadataSymbol] as SystemMetadata;
-    }
-    throw new ErrMissingSystemMetadata(system);
-}
-
-
-export function hasMetadata(ctor: Function): ctor is Required<FunctionWithMetadata> {
-    return SystemMetadataSymbol in ctor;
-}
-
-export function isSystem(ctor: Function): boolean {
-    return hasMetadata(ctor);
-}
-
-
-export type SystemCtor<T extends SystemBase = SystemBase> = ClassType<T>;
-
-/**
- * Arguments passed to {@link SystemBase.compute} on each {@link SystemsManager.update} call.
- */
-export type SystemComputeContext = {
-    /** Entity IDs from the query for this {@link SystemBase.compute} invocation. */
-    entities: number[];
-    /** ECS world instance. */
-    world: World;
-    /** Delta time (seconds or your engine's convention) since the previous update. */
-    dt: number;
-};
-
-/**
- * Base class for ECS systems executed by {@link SystemsManager}.
- *
- * Subclasses declare which components they iterate over (`queryComponents`), which component
- * types must exist in the world for registration (`requiredComponents`), and optional ordering
- * relative to other systems (`computeAfter` / `super(OtherSystem)`).
- */
-export abstract class SystemBase {
-    /**
-     * Logic for one systems pass: run for all entities in {@link SystemComputeContext.entities}.
-     */
-    public abstract compute(ctx: SystemComputeContext): void;
-
-    public onInit?(world: World): void;
-};
-
-
-export class SystemsManager {
-    private systems_ = new Map<SystemCtor, SystemBase>();
-    private executionOrder_: SystemBase[] = [];
-    private requiredComponents_: Set<ComponentType> = new Set();
-
-    private dirty_ = true;
-
-    constructor(
-        private readonly world: World,
-    ) { }
-
-    public getRequiredComponents(): ComponentType[] {
-        return Array.from(this.requiredComponents_);
-    }
-
-    public register<T extends SystemBase>(sys: T): void {
-        const ctor = sys.constructor as SystemCtor<T>;
-        if (this.systems_.has(ctor)) throw new Error("Duplicate system");
-        const { query, requiredComponents } = getSystemMetadata(ctor);
-
-        this.systems_.set(ctor, sys);
-
-        const q = query;
-
-        for (const c of q.include ?? [])
-            this.requiredComponents_.add(c);
-
-        for (const c of q.exclude ?? [])
-            this.requiredComponents_.add(c);
-
-        for (const c of q.anyOf ?? [])
-            this.requiredComponents_.add(c);
-        for (const c of requiredComponents)
-            this.requiredComponents_.add(c);
-    }
-
-    public build(): void {
-        this.buildSystemsArray();
-        for (const sys of this.systems_.values())
-            sys.onInit?.(this.world);
-    }
-
-    private rebuild(): void {
-        this.build();
-    };
-
-    public get<T extends SystemBase>(ctor: SystemCtor<T>): T {
-        const s = this.systems_.get(ctor);
-
-        if (!s)
-            throw new Error("System not registered");
-        return s as T;
-    }
-
-    public update(dt: number): void {
-        if (this.dirty_)
-            this.rebuild();
-
-        this.world.events.swapAll();
-
-        for (const s of this.executionOrder_) {
-            const { query } = getSystemMetadata(s.constructor as SystemCtor)
-            const entities = this.world.query(query);
-            s.compute({ entities, world: this.world, dt });
-        }
-    }
-
-    private buildSystemsArray(): void {
-        const map = new Map<SystemCtor, DAGNode<SystemBase>>();
-
-        for (const [ctor, system] of this.systems_.entries()) {
-            map.set(ctor, new DAGNode(system));
-        }
-
-        for (const ctor of this.systems_.keys()) {
-            const currentNode = map.get(ctor)!;
-            const { computeAfter } = getSystemMetadata(ctor);
-            for (const depCtor of computeAfter ?? []) {
-                const depNode = map.get(depCtor);
-                if (!depNode) {
-                    throw new Error(`Dependency ${depCtor.name} not registered`);
-                }
-
-                depNode.vertices.push(currentNode);
-            }
-        }
-
-        this.executionOrder_ = topologicalSort(map.values()).map(x => x.data);
-    }
-}

package/ecs/world.ts

@@ -1,99 +0,0 @@
-/*
-ECS World implementation
-⢀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-⢻⣿⡗⢶⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣠⣄
-⠀⢻⣇⠀⠈⠙⠳⣦⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⠶⠛⠋⣹⣿⡿
-⠀⠀⠹⣆⠀⠀⠀⠀⠙⢷⣄⣀⣀⣀⣤⣤⣤⣄⣀⣴⠞⠋⠉⠀⠀⠀⢀⣿⡟⠁
-⠀⠀⠀⠙⢷⡀⠀⠀⠀⠀⠉⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⡾⠋⠀⠀
-⠀⠀⠀⠀⠈⠻⡶⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣠⡾⠋⠀⠀⠀⠀
-⠀⠀⠀⠀⠀⣼⠃⠀⢠⠒⣆⠀⠀⠀⠀⠀⠀⢠⢲⣄⠀⠀⠀⢻⣆⠀⠀⠀⠀⠀
-⠀⠀⠀⠀⢰⡏⠀⠀⠈⠛⠋⠀⢀⣀⡀⠀⠀⠘⠛⠃⠀⠀⠀⠈⣿⡀⠀⠀⠀⠀
-⠀⠀⠀⠀⣾⡟⠛⢳⠀⠀⠀⠀⠀⣉⣀⠀⠀⠀⠀⣰⢛⠙⣶⠀⢹⣇⠀⠀⠀⠀
-⠀⠀⠀⠀⢿⡗⠛⠋⠀⠀⠀⠀⣾⠋⠀⢱⠀⠀⠀⠘⠲⠗⠋⠀⠈⣿⠀⠀⠀⠀
-⠀⠀⠀⠀⠘⢷⡀⠀⠀⠀⠀⠀⠈⠓⠒⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⡇⠀⠀⠀
-⠀⠀⠀⠀⠀⠈⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣧⠀⠀⠀
-⠀⠀⠀⠀⠀⠈⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠁⠀⠀⠀
-*/
-
-import { type ClassType, type ComponentType } from "@draug/types/class";
-import { EntitiesManager, type EntityID, EntityRef } from "./entity";
-import { SystemsManager } from "./system";
-import { ECS_DEFAULTS } from "./constant";
-import { EventBus } from "./events-buffer";
-import { ComponentsManager } from "./components";
-import { ResourcesManager } from "./resources/resources";
-import { Commands } from "./command";
-import { QueryManager, type QueryParameters } from "./query";
-import { PluginsManager } from "../plugin";
-
-export class World {
-    public readonly entities = new EntitiesManager();
-    public readonly components = new ComponentsManager();
-    public readonly systems = new SystemsManager(this);
-    public readonly events = new EventBus();
-    public readonly resources = new ResourcesManager();
-    public readonly commands = new Commands(this);
-    public readonly queries = new QueryManager(this);
-    public readonly plugins = new PluginsManager();
-
-    private entityRefs_ = new Map<number, EntityRef>();
-
-    constructor(maxEntityCount: number = ECS_DEFAULTS.MAX_ENTITY_COUNT) {
-        this.components = new ComponentsManager(maxEntityCount);
-    }
-
-    public getEntityRef(id: number): EntityRef {
-        let ref = this.entityRefs_.get(id);
-        if (!ref) {
-            ref = new EntityRef(this, id);
-            this.entityRefs_.set(id, ref);
-        }
-        return ref;
-    }
-    public query(params: QueryParameters): number[] {
-        return this.queries.get(params);
-    }
-
-    public removeComponent<T extends object>(ref: EntityRef, component: ComponentType<T>): void;
-    public removeComponent<T extends object>(entity: EntityID, component: ComponentType<T>): void;
-    public removeComponent<T extends object>(
-        entity: EntityID | EntityRef,
-        component: ComponentType<T>
-    ): void {
-        const id = typeof entity === 'number' ? entity : entity.id;
-
-        const storage = this.components.getStorage(component);
-        storage.remove(id);
-
-        this.queries.invalidate(component);
-    }
-
-    public addComponent<T extends object>(id: EntityID, component: ClassType<T>, initFn?: (obj: T) => void): T;
-    public addComponent<T extends object>(id: EntityRef, component: ClassType<T>, initFn?: (obj: T) => void): T
-    public addComponent<T extends object>(entity: EntityID | EntityRef, component: ClassType<T>, initFn?: (obj: T) => void): T {
-        const storage = this.components.getStorage(component);
-        let id: number;
-        if (typeof entity === 'number') {
-            id = entity;
-        } else {
-            id = entity.id;
-        }
-        const c = storage.add(id, (o) => {
-            if (initFn) {
-                initFn(o);
-            }
-            return o;
-        });
-        this.queries.invalidate(component);
-        return c;
-    };
-
-    public update(dt: number): void {
-        this.systems.update(dt);
-        this.commands.flush(this);
-    }
-
-    public build(): void {
-        this.plugins.build();
-    }
-};

package/index.ts

@@ -1,74 +0,0 @@
-export {
-    System,
-    SystemBase,
-    SystemError,
-    ErrMissingSystemMetadata,
-    ErrNotASystem,
-    isSystem,
-    getSystemMetadata,
-    SystemsManager,
-    type SystemComputeContext
-} from './ecs/system';
-
-export {
-    World
-} from './ecs/world';
-
-export {
-    Component,
-    ComponentAlreadyRegisteredError,
-    ComponentStorage,
-    ComponentsManager,
-    type IStorage,
-    SingletonStorage,
-} from './ecs/components';
-
-export { ResourcesManager } from './ecs/resources';
-
-export {
-    entry,
-    Commands,
-    type CreateEntityComponentEntry,
-    type ComponentInitFn,
-    type WorldCommand,
-} from './ecs/command';
-
-export {
-    EntityMaskNotFoundError,
-    EntityRef,
-    EntitiesManager,
-    UnregisteredComponentStorageError,
-    type EntityID,
-} from './ecs/entity';
-
-export {
-    Plugin,
-    isPlugin,
-    getPluginMetadata,
-    PluginBase,
-    PluginsManager,
-    PluginError,
-    ErrMissingPluginMetadata,
-    ErrNotAPlugin,
-    ErrPluginNotInit,
-    ErrUnknownPlugin,
-    type PluginID,
-    type PluginMetadata,
-    type PluginDependencies,
-} from './plugin';
-
-export {
-    EventBuffer,
-    EventBus,
-    createEventKey,
-} from './ecs/events-buffer';
-
-export {
-    Clock,
-    type TimeSource,
-} from './runtime/clock';
-
-export { GameLoop, type StepFunction } from './runtime/game-loop';
-export {
-    Runtime
-} from './runtime/runtime';

package/plugin/index.ts

@@ -1,15 +0,0 @@
-export {
-    Plugin,
-    isPlugin,
-    getPluginMetadata,
-    PluginBase,
-    PluginsManager,
-    PluginError,
-    ErrMissingPluginMetadata,
-    ErrNotAPlugin,
-    ErrPluginNotInit,
-    ErrUnknownPlugin,
-    type PluginID,
-    type PluginMetadata,
-    type PluginDependencies,
-} from './plugin'