{"version":3,"sources":["../src/world.ts","../src/component.ts","../src/mask.ts","../src/entity.ts"],"sourcesContent":["import { System } from './system';\nimport { Entity, EntityBuilder, EntityId, EntityOpts } from './entity';\nimport { Query } from './query';\nimport { ComponentConstructor } from './component';\n\nexport type SystemAndProps<T extends { new (...args: unknown[]): System }> = {\n    system: T;\n    props: ConstructorParameters<T>;\n};\n\nexport class World {\n    private systems: System[] = [];\n    private queryRegistry: Map<ComponentConstructor, Query[]> = new Map();\n    private allQueries: Array<Query> = [];\n    /**\n     * Queries that have only Without aspects don't appear in queryRegistry\n     * under any component, so we keep them in a flat list and check them\n     * on every entity-component change.\n     */\n    private exclusiveOnlyQueries: Array<Query> = [];\n    /**\n     * Monotonic tick stamped onto Query._visitedTick during\n     * refreshQueriesForEntity. Lets us dedupe per-entity work across multiple\n     * components without allocating a Set per build.\n     */\n    private _refreshTick = 0;\n    private entities: Map<EntityId, Entity> = new Map();\n    private deadEntities: Array<Entity> = [];\n    private entitiesToBePurged: Array<Entity> = [];\n    private initialized = false;\n\n    private onRunCallbacks: Array<(delta: number) => void> = [];\n\n    // eslint-disable-next-line @typescript-eslint/no-empty-function\n    private constructor() {}\n\n    static create(): World {\n        return new World();\n    }\n\n    destroy(): void {\n        this.systems = [];\n        this.queryRegistry.clear();\n        this.allQueries = [];\n        this.exclusiveOnlyQueries = [];\n        this.entities.clear();\n        this.deadEntities = [];\n        this.entitiesToBePurged = [];\n        this.initialized = false;\n    }\n\n    public getEntityById(id: EntityId) {\n        return this.entities.get(id);\n    }\n\n    /**\n     * Keeping track of which queries are interested in which components,\n     * in order to reduce the amount of iterations when updating entity lists\n     */\n    addToQueryRegistry(\n        key: ComponentConstructor,\n        query: Query,\n        registry: Map<ComponentConstructor, Query[]>\n    ): void {\n        if (!registry.has(key)) {\n            registry.set(key, [query]);\n        } else {\n            registry.get(key)?.push(query);\n        }\n    }\n\n    mapAspects(system: System): void {\n        system.queries.forEach((query: Query) => {\n            const aspects = query.aspects;\n            aspects.forEach((a) => {\n                this.addToQueryRegistry(\n                    a.component,\n                    query,\n                    this.queryRegistry\n                );\n            });\n            if (query.hasOnlyExclusiveAspects) {\n                this.exclusiveOnlyQueries.push(query);\n            }\n            this.allQueries.push(query);\n        });\n    }\n\n    addSystem<T extends { new (...args: any[]): System }>(\n        systemClass: T,\n        ...args: ConstructorParameters<T>\n    ) {\n        const systemInstance = new systemClass(...args);\n        systemInstance.world = this;\n        this.mapAspects(systemInstance);\n        this.systems.push(systemInstance);\n\n        return this;\n    }\n\n    /**\n     * Adds a callback that is called on each world.run\n     */\n    onRun = (cb: (delta: number) => void) => {\n        this.onRunCallbacks.push(cb);\n    };\n\n    /**\n     * Run all of the world's systems\n     * @param delta Optional, defaults to 1\n     */\n    run = (delta = 1): void => {\n        if (!this.initialized) {\n            this.systems.sort((a, b) => {\n                const orderA = a.order ?? 0;\n                const orderB = b.order ?? 0;\n                return orderA - orderB;\n            });\n            this.systems.forEach((system) => {\n                system.initialize();\n            });\n            this.initialized = true;\n        }\n\n        /**\n         * Flush every query so that they get fresh changesets to track\n         */\n        this.allQueries.forEach((query) => {\n            query.flushQuery();\n        });\n\n        /**\n         * Run each system\n         */\n        this.systems.forEach((system: System) => {\n            system.run(delta);\n        });\n\n        this.processGraveyard();\n\n        this.onRunCallbacks.forEach((cb) => cb(delta));\n    };\n\n    mapEntity(entity: Entity) {\n        if (this.entities.has(entity.id)) {\n            throw new Error(\n                `Entity with id \"${entity.id}\" already exists in the world.`\n            );\n        }\n        this.entities.set(entity.id, entity);\n    }\n\n    updateRegistry(component: ComponentConstructor, entity: Entity): void {\n        this.queryRegistry.get(component)?.forEach((query: Query) => {\n            query.updateRegistry(entity);\n        });\n        for (const q of this.exclusiveOnlyQueries) {\n            q.updateRegistry(entity);\n        }\n    }\n\n    /**\n     * Refresh every query that cares about any of the given components, exactly\n     * once per query. Used by EntityBuilder.build so that queries spanning\n     * multiple just-added components don't get re-checked per component.\n     */\n    refreshQueriesForEntity(\n        entity: Entity,\n        components: ComponentConstructor[]\n    ): void {\n        const tick = ++this._refreshTick;\n        for (const c of components) {\n            const queries = this.queryRegistry.get(c);\n            if (!queries) continue;\n            for (const q of queries) {\n                if (q._visitedTick === tick) continue;\n                q._visitedTick = tick;\n                q.updateRegistry(entity);\n            }\n        }\n        for (const q of this.exclusiveOnlyQueries) {\n            if (q._visitedTick === tick) continue;\n            q._visitedTick = tick;\n            q.updateRegistry(entity);\n        }\n    }\n\n    spawnEntity(opts?: EntityOpts): EntityBuilder {\n        return EntityBuilder.create(this, opts);\n    }\n\n    processGraveyard() {\n        this.entitiesToBePurged.forEach((entity) => {\n            entity.purge();\n            this.entities.delete(entity.id);\n        });\n        this.entitiesToBePurged = this.deadEntities.slice();\n        this.deadEntities.length = 0;\n    }\n\n    markDeadEntity(entity: Entity) {\n        this.deadEntities.push(entity);\n    }\n\n    /**\n     * Used for testing\n     */\n    getSystem<T extends { new (...args: never): System }>(\n        systemClass: T\n    ): InstanceType<T> {\n        return this.systems.find(\n            (s) => s instanceof systemClass\n        ) as InstanceType<T>;\n    }\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Entity } from './entity';\nimport { pendingFields, pendingInitializers } from './decorators';\n\nexport type ComponentId = number;\nexport type ComponentName = string;\nexport type ComponentField = {\n    fieldName: string;\n    defaultValue?: unknown;\n};\n\n/**\n * Component that can be attached to entities.\n */\nexport abstract class Component {\n    /**\n     * Bitflag id assigned to a component class at registration time.\n     * Keyed by the class reference itself, not by class name, so the ECS\n     * survives identifier mangling by minifiers and obfuscators.\n     */\n    static ComponentIdMap: Map<ComponentConstructor, ComponentId> = new Map();\n\n    static ComponentFieldMap: Map<\n        ComponentConstructor,\n        Map<string, ComponentField>\n    > = new Map();\n\n    static ComponentFieldInitializeMap: Map<\n        ComponentConstructor,\n        Map<string, Array<string>>\n    > = new Map();\n\n    static maxId = 0;\n\n    declare componentId: ComponentId;\n\n    private declare entity: Entity;\n\n    setValues(values: Record<string, any>): void {\n        const ctor = this.constructor as ComponentConstructor;\n        const fields = Component.ComponentFieldMap.get(ctor);\n        const initializers = Component.ComponentFieldInitializeMap.get(ctor);\n\n        if (!fields) {\n            return;\n        }\n\n        fields.forEach(({ fieldName }) => {\n            if (typeof values[fieldName] === 'undefined') {\n                throw new Error(\n                    `Value not provided for ${fieldName} on component ${this.constructor.name}.`\n                );\n            } else {\n                (this as any)[fieldName] = values[fieldName];\n\n                if (initializers && initializers.has(fieldName)) {\n                    initializers.get(fieldName)?.forEach((otherField) => {\n                        (this as any)[otherField] = values[fieldName];\n                    });\n                }\n            }\n        });\n    }\n    setEntity(entity: Entity): void {\n        this.entity = entity;\n    }\n\n    getEntity(): Entity {\n        if (!this.entity) {\n            throw new Error(\n                \"Component tried to fetch it's entity, but none was found\"\n            );\n        }\n        return this.entity;\n    }\n\n    onComponentRemoved() {\n        // no-op\n    }\n\n    toString(): string {\n        return `${this.constructor.name}`;\n    }\n}\n\ntype NonFunctionPropertyNames<T> = {\n    // eslint-disable-next-line @typescript-eslint/ban-types\n    [K in keyof T]: T[K] extends Function ? never : K;\n}[keyof T];\n\nexport type ComponentArgs<C> = {\n    [Property in Exclude<\n        NonFunctionPropertyNames<C>,\n        keyof Component\n    >]: C[Property];\n};\nexport type ComponentConstructor = { new (...args: any[]): Component };\n\nexport const registerComponentWithSpecificId = <T extends ComponentConstructor>(\n    constructor: T,\n    id: number\n) => {\n    registerComponent(constructor, id);\n};\n\nexport function RegisterComponent<T extends ComponentConstructor>(\n    value: T,\n    _context: ClassDecoratorContext\n): void {\n    Component.maxId++;\n    const newComponentId = Component.maxId;\n    registerComponent(value, newComponentId);\n\n    const fields = pendingFields.splice(0);\n    const fieldMap = Component.ComponentFieldMap.get(value);\n    if (fieldMap) {\n        for (const f of fields) {\n            fieldMap.set(f.fieldName, f);\n        }\n    }\n\n    const initializers = pendingInitializers.splice(0);\n    if (initializers.length > 0) {\n        let initMap = Component.ComponentFieldInitializeMap.get(value);\n        if (!initMap) {\n            initMap = new Map();\n            Component.ComponentFieldInitializeMap.set(value, initMap);\n        }\n        for (const init of initializers) {\n            if (!initMap.has(init.initFrom)) {\n                initMap.set(init.initFrom, []);\n            }\n            initMap.get(init.initFrom)?.push(init.field);\n        }\n    }\n}\n\nconst registerComponent = (\n    constructor: ComponentConstructor,\n    newComponentId: number\n) => {\n    constructor.prototype.componentId = newComponentId;\n    Component.ComponentIdMap.set(constructor, newComponentId);\n\n    if (!Component.ComponentFieldMap.has(constructor)) {\n        Component.ComponentFieldMap.set(constructor, new Map());\n    }\n};\n","import { Component } from './component';\n\nexport class Mask {\n    private _mask: Uint32Array;\n    private _enabled = false;\n\n    constructor(size = Component.maxId) {\n        // Uint32Array holds 32 bits for every unit of size, so we need the no. of components\n        // divided by 32 to mask all components\n        this._mask = new Uint32Array(Math.ceil(size / 32));\n    }\n\n    enable(): void {\n        this._enabled = true;\n    }\n\n    get enabled(): boolean {\n        return this._enabled;\n    }\n\n    get mask(): Uint32Array {\n        return this._mask;\n    }\n\n    get empty(): boolean {\n        return this._mask.every((m) => m === 0);\n    }\n\n    /**\n     * Checks another mask to see it is fulfilled by the flags in this mask\n     * @param otherMask Uint32Array to be compared with this mask\n     * @returns True if the provided mask is satisfied by this mask\n     */\n    public fulfills = (otherMask: Mask): boolean => {\n        if (otherMask.mask.length !== this._mask.length) {\n            throw new Error('Comparing masks of different sizes not allowed.');\n        }\n        return this._mask.every((m, index) =>\n            this.checkMask(m, otherMask.mask[index])\n        );\n    };\n\n    /**\n     * Checks another mask to see it contains all flags in this mask\n     * @param otherMask Uint32Array to be compared with this mask\n     * @returns True if the provided mask is satisfied by this mask\n     */\n    public fulfilledBy = (otherMask: Mask): boolean => {\n        if (otherMask.mask.length !== this._mask.length) {\n            throw new Error('Comparing masks of different sizes not allowed.');\n        }\n        return this._mask.every((m, index) =>\n            this.checkMask(otherMask.mask[index], m)\n        );\n    };\n\n    /**\n     * @param checkingMask The mask that needs to be met to fulfill the condition\n     * @param requiredMask The other mask that needs to match up with the first mask\n     * @returns Whether the masks match or not\n     */\n    private checkMask = (\n        checkingMask: number,\n        requiredMask: number\n    ): boolean => {\n        return (\n            (checkingMask & requiredMask) >>> 0 === requiredMask ||\n            checkingMask === requiredMask // second condition checking if they're both 0\n        );\n    };\n\n    /**\n     * Flips all bits in the mask to 1\n     */\n    flipAllToOne = () => {\n        this._mask.fill(~0 >>> 0);\n    };\n\n    /**\n     * Flip on a flag in this mask\n     * @param bitPosition The bit flag to flip, typically a componentId.\n     */\n    flipOn = (bitPosition: number) => {\n        this._mask[Math.floor(bitPosition / 32)] |=\n            (1 << bitPosition % 32) >>> 0;\n    };\n\n    /**\n     * Flip off a flag on this mask\n     * @param bitPosition The bit flag to flip, typically a componentId.\n     */\n    flipOff = (bitPosition: number) => {\n        this._mask[Math.floor(bitPosition / 32)] &= ~(\n            (1 << bitPosition % 32) >>>\n            0\n        );\n    };\n\n    toString(): string {\n        const decToBin = (dec: number) => {\n            return (dec >>> 0).toString(2);\n        };\n        let string = '|';\n        for (const mask of this.mask) {\n            const stringMask = decToBin(mask);\n            string += stringMask.padEnd(32, '0');\n            string += '|';\n        }\n        return string;\n    }\n\n    get maskString() {\n        return this.toString();\n    }\n}\n","/* eslint-disable @typescript-eslint/ban-types */\nimport {\n    Component,\n    ComponentArgs,\n    ComponentConstructor,\n    ComponentName\n} from './component';\nimport { Mask } from './mask';\nimport { Query, QueryId } from './query';\nimport { World } from './world';\n\nexport type EntityId = string;\n\nlet nextEntitySerial = 0;\nconst generateEntityId = (): EntityId => `e${nextEntitySerial++}`;\n\nexport type IfEquals<T, U, Y = unknown, N = never> = (<G>() => G extends T\n    ? 1\n    : 2) extends <G>() => G extends U ? 1 : 2\n    ? Y\n    : N;\nexport type KeysOfType<T, U> = {\n    [K in keyof T]: T[K] extends U ? K : never;\n}[keyof T];\nexport type RequiredKeys<T> = Exclude<\n    KeysOfType<T, Exclude<T[keyof T], undefined>>,\n    undefined\n>;\nexport type ExcludeOptionalProps<T> = Pick<T, RequiredKeys<T>>;\n\ntype RequiredFieldsOnly<T> = {\n    [K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K];\n};\n\n/**\n * A base class from which all game entities derive, supports adding and removing {@link Component | Components}\n */\nexport class Entity {\n    public id: EntityId;\n    public name = 'unknown';\n    public alive = true;\n\n    private world: World;\n    private _componentMask: Mask;\n    private cleanupCallbacks: { (entity: Entity): void }[] = [];\n\n    private components: Map<ComponentConstructor, Component>;\n    private currentQueries = new Map<QueryId, Query>();\n\n    constructor(world: World, opts?: EntityOpts) {\n        this.id = opts?.id ?? generateEntityId();\n        this.name = opts?.name ?? 'unnamed';\n        this.components = new Map();\n        this.world = world;\n        this._componentMask = new Mask();\n    }\n\n    addComponent<T extends Component>(\n        component: { new (): T },\n        args?: ComponentArgs<T>\n    ): void {\n        this._addComponent(component, args);\n        this.world.updateRegistry(component, this);\n    }\n\n    /**\n     * Internal: add a component without notifying the world's query registry.\n     * Caller MUST follow up with World.refreshQueriesForEntity (or addComponent\n     * for a single component) so queries see the new state. Used by\n     * EntityBuilder.build to dedupe per-query work across many components.\n     */\n    _addComponent<T extends Component>(\n        component: { new (): T },\n        args?: ComponentArgs<T>\n    ): void {\n        const componentInstance = new component();\n        componentInstance.setEntity(this);\n        const fieldMap = Component.ComponentFieldMap.get(component);\n        if (fieldMap && fieldMap.size > 0 && args) {\n            componentInstance.setValues(args);\n        }\n\n        this.components.set(component, componentInstance);\n        this._componentMask.flipOn(componentInstance.componentId - 1);\n    }\n\n    /**\n     * Alias for {@link upsertComponent}\n     */\n    upsert<T extends Component>(\n        component: { new (): T },\n        args?: ComponentArgs<T>\n    ): void {\n        this.upsertComponent(component, args);\n    }\n\n    /**\n     * Add or update a given component\n     * @param component Component to update\n     * @param args Values to set on component\n     */\n    upsertComponent<T extends Component>(\n        component: { new (): T },\n        args?: ComponentArgs<T>\n    ): void {\n        if (!this.hasComponent(component)) {\n            this.addComponent(component, args);\n        } else {\n            this.components.get(component)?.setValues(args ?? {});\n        }\n    }\n\n    /**\n     * Alias for {@link getComponent}\n     */\n    get<T extends { new (...args: never): Component }>(\n        componentClass: T | Component\n    ): InstanceType<T> {\n        return this.getComponent(componentClass);\n    }\n\n    /**\n     * Gets a component from the entity by class\n     * @param componentClass Class of component to get\n     * @returns Component instance\n     */\n    getComponent<T extends { new (...args: never): Component }>(\n        componentClass: T | Component\n    ): InstanceType<T> {\n        const key =\n            componentClass instanceof Component\n                ? (componentClass.constructor as ComponentConstructor)\n                : (componentClass as unknown as ComponentConstructor);\n        return this.components.get(key) as InstanceType<T>;\n    }\n\n    /**\n     * @deprecated Class names may be mangled by minifiers/obfuscators.\n     * Iterate components directly or work with class references instead.\n     */\n    getComponentNames(): ComponentName[] {\n        return Array.from(this.components.keys()).map((c) => c.name);\n    }\n\n    get componentMask(): Mask {\n        return this._componentMask;\n    }\n\n    /**\n     * Alias for {@link hasComponent}\n     */\n    has<T extends { new (...args: never): Component }>(\n        componentClass: T | Component\n    ): boolean {\n        return this.hasComponent(componentClass);\n    }\n\n    /**\n     * Check if an entity has a component.\n     * @param componentClass Component class to check\n     * @returns boolean true/false depending on whether the component is on the entity\n     */\n    hasComponent<T extends { new (...args: never): Component }>(\n        componentClass: T | Component\n    ): boolean {\n        const key =\n            componentClass instanceof Component\n                ? (componentClass.constructor as ComponentConstructor)\n                : (componentClass as unknown as ComponentConstructor);\n        return this.components.has(key);\n    }\n\n    /**\n     * Alias for {@link removeComponent}\n     */\n    remove<T extends { new (...args: never): Component }>(\n        componentClass: T\n    ): boolean {\n        return this.removeComponent(componentClass);\n    }\n\n    /**\n     * Removes a component from entity by class. Returns true if the component\n     * was present and removed, false if the entity did not have it.\n     * @param componentClass Component class to remove\n     */\n    removeComponent<T extends { new (...args: never): Component }>(\n        componentClass: T\n    ): boolean {\n        const ctor = componentClass as unknown as ComponentConstructor;\n        if (!this.components.has(ctor)) {\n            return false;\n        }\n\n        const id = Component.ComponentIdMap.get(ctor);\n        if (id !== undefined) {\n            this._componentMask.flipOff(id - 1);\n        }\n\n        this.components.get(ctor)?.onComponentRemoved();\n        this.components.delete(ctor);\n\n        this.world.updateRegistry(ctor, this);\n        return true;\n    }\n\n    /**\n     * @deprecated Class names may be mangled by minifiers/obfuscators.\n     * Use {@link removeComponent} with a class reference instead.\n     */\n    removeComponentByName(componentName: ComponentName): boolean {\n        for (const ctor of this.components.keys()) {\n            if (ctor.name === componentName) {\n                return this.removeComponent(ctor);\n            }\n        }\n        return false;\n    }\n\n    /**\n     * Check whether this entity is the same as passed entity\n     */\n    equals(other: Entity): boolean {\n        return this.id === other.id;\n    }\n\n    registerQuery(query: Query): void {\n        this.currentQueries.set(query.id, query);\n    }\n\n    unregisterQuery(query: Query): void {\n        this.currentQueries.delete(query.id);\n    }\n\n    addCleanupCallback(callback: (entity: Entity) => void): void {\n        this.cleanupCallbacks.push(callback);\n    }\n\n    destroy(): void {\n        // use maintained list of registered systems and unregister entity\n        this.currentQueries.forEach((q) => {\n            q.unregisterEntity(this);\n        });\n\n        this.alive = false;\n\n        this.world.markDeadEntity(this);\n    }\n\n    purge(): void {\n        // Snapshot keys to avoid mutating during iteration.\n        const ctors = Array.from(this.components.keys());\n        ctors.forEach((ctor) => {\n            this.removeComponent(ctor);\n        });\n\n        this.cleanupCallbacks.forEach((cb) => {\n            cb(this);\n        });\n    }\n}\n\nexport interface IEntityBuilder {\n    build(): Entity;\n}\n\nexport type EntityOpts = {\n    id?: string;\n    name?: string;\n};\nexport class EntityBuilder implements IEntityBuilder {\n    private world: World;\n    private opts: EntityOpts | undefined;\n    private componentRecipes: Array<{\n        constructor: { new (): unknown };\n        args?: Record<any, unknown>;\n    }> = [];\n\n    static create(world: World, opts?: EntityOpts): EntityBuilder {\n        return new EntityBuilder(world, opts);\n    }\n\n    constructor(world: World, opts?: EntityOpts) {\n        this.world = world;\n        this.opts = opts;\n    }\n\n    with<T extends Component>(\n        componentConstructor: { new (): T },\n        args?: ComponentArgs<T>\n    ): EntityBuilder {\n        this.componentRecipes.push({\n            constructor: componentConstructor,\n            args: args\n        });\n        return this;\n    }\n\n    build(): Entity {\n        const entity = new Entity(this.world, this.opts);\n        this.componentRecipes.forEach(({ constructor, args }) => {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            entity._addComponent<any>(constructor, args);\n        });\n\n        this.world.mapEntity(entity);\n        this.world.refreshQueriesForEntity(\n            entity,\n            this.componentRecipes.map((r) => r.constructor as ComponentConstructor)\n        );\n        return entity;\n    }\n}\n"],"mappings":"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","names":[]}