@multiplekex/shallot 0.1.0

package/src/core/state.ts

@@ -0,0 +1,295 @@
+import {
+    addComponent,
+    addEntity,
+    createWorld,
+    entityExists,
+    getAllEntities,
+    getComponent,
+    getEntityComponents,
+    getRelationTargets,
+    hasComponent,
+    query,
+    removeComponent,
+    removeComponents,
+    removeEntity,
+    type ComponentRef,
+    type World,
+} from "bitecs";
+import { Scheduler, Time, type GameTime, type System } from "./scheduler";
+import type { RelationDef } from "./relation";
+import type { Plugin } from "./types";
+import type { StateBuilder } from "./builder";
+import { initRuntime, type Runtime } from "./runtime";
+import {
+    registerComponent,
+    getTraits,
+    getRegisteredComponent,
+    directAccessor,
+    type ComponentData,
+    type FieldAccessor,
+} from "./component";
+import { type ResourceKey } from "./resource";
+import { toCamelCase } from "./strings";
+
+export const MAX_ENTITIES = 65536;
+
+export class State {
+    readonly world: World;
+    readonly scheduler = new Scheduler();
+    readonly canvas: HTMLCanvasElement | null;
+
+    private _resources = new Map<symbol, unknown>();
+    private _disposed = false;
+    private _running = false;
+    private _runtime: Runtime | null = null;
+    private _lastTime = 0;
+    private _fieldAccessors: Map<number, FieldAccessor> | null = null;
+
+    get time(): Readonly<GameTime> {
+        return this.scheduler.time;
+    }
+
+    get running(): boolean {
+        return this._running;
+    }
+
+    static Builder: (new () => StateBuilder) | null = null;
+
+    static new(): StateBuilder {
+        if (!State.Builder) {
+            throw new Error("StateBuilder not injected. Import from 'shallot' or 'shallot/core'.");
+        }
+        return new State.Builder();
+    }
+
+    constructor(canvas: HTMLCanvasElement | null = null) {
+        this.world = createWorld();
+        this.canvas = canvas;
+    }
+
+    setResource<T>(key: ResourceKey<T>, value: T): void {
+        this._resources.set(key, value);
+    }
+
+    getResource<T>(key: ResourceKey<T>): T | undefined {
+        return this._resources.get(key) as T | undefined;
+    }
+
+    deleteResource<T>(key: ResourceKey<T>): boolean {
+        return this._resources.delete(key);
+    }
+
+    async start(runtime?: Runtime): Promise<void> {
+        if (this._running) return;
+        this._runtime = runtime ?? (await initRuntime());
+        this._running = true;
+        this._lastTime = this._runtime.now();
+        this.scheduleFrame();
+    }
+
+    stop(): void {
+        this._running = false;
+    }
+
+    private scheduleFrame(): void {
+        if (!this._running || !this._runtime) return;
+        this._runtime.requestFrame(() => this.tick());
+    }
+
+    private tick(): void {
+        if (!this._running || !this._runtime) return;
+        const now = this._runtime.now();
+        const dt = (now - this._lastTime) / 1000;
+        this._lastTime = now;
+        this.step(dt);
+        this.scheduleFrame();
+    }
+
+    register(pluginOrSystem: Plugin | System): void {
+        if (
+            "update" in pluginOrSystem ||
+            "setup" in pluginOrSystem ||
+            "dispose" in pluginOrSystem
+        ) {
+            this.scheduler.register(pluginOrSystem as System);
+        } else {
+            const plugin = pluginOrSystem as Plugin;
+            if (plugin.components) {
+                for (const [name, component] of Object.entries(plugin.components)) {
+                    registerComponent(name, component);
+                }
+            }
+            if (plugin.systems) {
+                for (const system of plugin.systems) {
+                    this.scheduler.register(system);
+                }
+            }
+        }
+    }
+
+    unregister(system: System): void {
+        this.scheduler.unregister(system);
+    }
+
+    step(deltaTime = Time.DEFAULT_DT): void {
+        this.scheduler.step(this, deltaTime);
+    }
+
+    addEntity(): number {
+        const eid = addEntity(this.world);
+        if (eid >= MAX_ENTITIES) {
+            throw new Error(`Entity limit exceeded: ${eid} >= ${MAX_ENTITIES}`);
+        }
+        return eid;
+    }
+
+    removeEntity(eid: number): void {
+        this._fieldAccessors?.delete(eid);
+        removeEntity(this.world, eid);
+    }
+
+    entityExists(eid: number): boolean {
+        return entityExists(this.world, eid);
+    }
+
+    getAllEntities(): readonly number[] {
+        return getAllEntities(this.world);
+    }
+
+    query(terms: ComponentRef[]): Iterable<number> {
+        return query(this.world, terms);
+    }
+
+    getEntityComponents(eid: number): ComponentRef[] {
+        return getEntityComponents(this.world, eid);
+    }
+
+    addComponent<T extends ComponentRef>(eid: number, component: T): void {
+        addComponent(this.world, eid, component);
+
+        const traits = getTraits(component as ComponentData);
+        if (traits?.defaults) {
+            const defaults = traits.defaults();
+            const comp = component as ComponentData;
+            for (const [field, value] of Object.entries(defaults)) {
+                const arr = comp[field];
+                if (arr != null) {
+                    arr[eid] = value;
+                }
+            }
+        }
+    }
+
+    addComponents(eid: number, ...components: ComponentRef[]): void {
+        for (const component of components) {
+            this.addComponent(eid, component);
+        }
+    }
+
+    removeComponent(eid: number, ...components: ComponentRef[]): void {
+        removeComponent(this.world, eid, ...components);
+    }
+
+    removeComponents(eid: number, ...components: ComponentRef[]): void {
+        removeComponents(this.world, eid, ...components);
+    }
+
+    hasComponent<T extends ComponentRef>(eid: number, component: T): boolean {
+        return hasComponent(this.world, eid, component);
+    }
+
+    getComponent<T extends ComponentRef>(eid: number, component: T) {
+        return getComponent(this.world, eid, component);
+    }
+
+    setComponent<T extends ComponentRef>(
+        eid: number,
+        component: T,
+        data: Record<string, number>
+    ): void {
+        this.addComponent(eid, component);
+        const comp = component as Record<string, number[]>;
+        for (const [field, value] of Object.entries(data)) {
+            const arr = comp[field];
+            if (arr != null) {
+                arr[eid] = value;
+            }
+        }
+    }
+
+    addRelation(subject: number, relation: RelationDef, target: number): void {
+        addComponent(this.world, subject, relation.relation(target));
+    }
+
+    hasRelation(subject: number, relation: RelationDef, target: number): boolean {
+        return hasComponent(this.world, subject, relation.relation(target));
+    }
+
+    getRelationTargets(subject: number, relation: RelationDef): number[] {
+        return getRelationTargets(this.world, subject, relation.relation);
+    }
+
+    getFirstRelationTarget(subject: number, relation: RelationDef): number {
+        const targets = getRelationTargets(this.world, subject, relation.relation);
+        return targets.length > 0 ? targets[0] : -1;
+    }
+
+    private ensureFieldAccessors(): Map<number, FieldAccessor> {
+        if (!this._fieldAccessors) {
+            this._fieldAccessors = new Map();
+        }
+        return this._fieldAccessors;
+    }
+
+    resolveFieldPath(path: string): { component: string; field: string } | null {
+        const dotIndex = path.lastIndexOf(".");
+        if (dotIndex === -1) return null;
+        return {
+            component: path.slice(0, dotIndex),
+            field: path.slice(dotIndex + 1),
+        };
+    }
+
+    bindFieldAccessor(
+        bindingId: number,
+        componentName: string,
+        fieldPath: string
+    ): FieldAccessor | null {
+        const registered = getRegisteredComponent(componentName);
+        if (!registered) return null;
+
+        const camelPath = toCamelCase(fieldPath);
+
+        const traits = getTraits(registered.component);
+        if (traits?.accessors?.[camelPath]) {
+            const accessor = traits.accessors[camelPath];
+            this.ensureFieldAccessors().set(bindingId, accessor);
+            return accessor;
+        }
+
+        const array = registered.component[camelPath];
+        if (array == null) return null;
+
+        const accessor = directAccessor(array, 1, 0);
+        this.ensureFieldAccessors().set(bindingId, accessor);
+        return accessor;
+    }
+
+    getFieldAccessor(bindingId: number): FieldAccessor | undefined {
+        return this._fieldAccessors?.get(bindingId);
+    }
+
+    removeFieldAccessor(bindingId: number): boolean {
+        return this._fieldAccessors?.delete(bindingId) ?? false;
+    }
+
+    dispose(): void {
+        if (this._disposed) return;
+        this.stop();
+        this._fieldAccessors = null;
+        for (const system of this.scheduler.systems) {
+            system.dispose?.(this);
+        }
+        this._disposed = true;
+    }
+}

package/src/core/strings.ts

@@ -0,0 +1,10 @@
+export function toKebabCase(str: string): string {
+    return str
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        .replace(/[\s_]+/g, "-")
+        .toLowerCase();
+}
+
+export function toCamelCase(str: string): string {
+    return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}

package/src/core/types.ts

@@ -0,0 +1,37 @@
+import type { System } from "./scheduler";
+import type { ComponentData } from "./component";
+import type { RelationDef } from "./relation";
+import type { State } from "./state";
+
+export interface Plugin {
+    readonly systems?: readonly System[];
+    readonly components?: Record<string, ComponentData>;
+    readonly relations?: readonly RelationDef[];
+    readonly dependencies?: readonly Plugin[];
+    readonly initialize?: (state: State) => void | Promise<void>;
+}
+
+export interface Loading {
+    show(): (() => void) | void;
+    update(progress: number): void;
+}
+
+export interface MouseState {
+    deltaX: number;
+    deltaY: number;
+    scrollDelta: number;
+    left: boolean;
+    right: boolean;
+    middle: boolean;
+}
+
+export interface InputState {
+    readonly mouse: Readonly<MouseState>;
+    isKeyDown(code: string): boolean;
+    isKeyPressed(code: string): boolean;
+    isKeyReleased(code: string): boolean;
+}
+
+export interface RenderContext {
+    readonly gpu: unknown;
+}