@multiplekex/shallot 0.1.0

package/src/standard/tween/tween.ts

@@ -0,0 +1,265 @@
+import {
+    defineRelation,
+    registerPostLoadHook,
+    type State,
+    type System,
+    type ParseContext,
+    type Plugin,
+} from "../../core";
+import { setTraits } from "../../core/component";
+import { getEasingIndex, getEasing } from "./easing";
+import {
+    Sequence,
+    Pause,
+    updateSequences,
+    ensureSequencesResolved,
+    checkSequenceCompletion,
+} from "./sequence";
+
+function parseTweenAttrs(attrs: Record<string, string>): Record<string, string> {
+    if (attrs._value) {
+        const parsed: Record<string, string> = {};
+        for (const part of attrs._value.split(";")) {
+            const colonIdx = part.indexOf(":");
+            if (colonIdx === -1) continue;
+            const key = part.slice(0, colonIdx).trim();
+            const value = part.slice(colonIdx + 1).trim();
+            if (key && value) parsed[key] = value;
+        }
+        return parsed;
+    }
+    return attrs;
+}
+
+export const TweenState = {
+    IDLE: 0,
+    PLAYING: 1,
+    COMPLETE: 2,
+} as const;
+
+export const Tween = {
+    state: [] as number[],
+    from: [] as number[],
+    to: [] as number[],
+    duration: [] as number[],
+    elapsed: [] as number[],
+    delay: [] as number[],
+    easingIndex: [] as number[],
+};
+
+setTraits(Tween, {
+    defaults: () => ({
+        state: TweenState.IDLE,
+        from: 0,
+        to: 0,
+        duration: 1,
+        elapsed: 0,
+        delay: 0,
+        easingIndex: 0,
+    }),
+    adapter: (attrs: Record<string, string>, state: State, context: ParseContext) => {
+        const parsed = parseTweenAttrs(attrs);
+        const result: Record<string, number> = {};
+
+        if (parsed.duration) result.duration = parseFloat(parsed.duration);
+        if (parsed.delay) result.delay = parseFloat(parsed.delay);
+        if (parsed.easing) result.easingIndex = getEasingIndex(parsed.easing);
+
+        if (parsed.target) {
+            setupTweenFromXml(state, context, parsed, context.currentEid);
+        }
+
+        return result;
+    },
+});
+
+export const TweenTarget = defineRelation("tween-target", {
+    exclusive: true,
+});
+
+interface ParsedTargetPath {
+    readonly entity: string;
+    readonly component: string;
+    readonly field: string;
+}
+
+function parseTargetPath(path: string): ParsedTargetPath | null {
+    if (!path.startsWith("@")) return null;
+
+    const rest = path.slice(1);
+    const firstDot = rest.indexOf(".");
+    if (firstDot === -1) return null;
+
+    const entity = rest.slice(0, firstDot);
+    const fieldPath = rest.slice(firstDot + 1);
+    const dotIndex = fieldPath.lastIndexOf(".");
+    if (dotIndex === -1) return null;
+
+    return {
+        entity,
+        component: fieldPath.slice(0, dotIndex),
+        field: fieldPath.slice(dotIndex + 1),
+    };
+}
+
+interface PendingTween {
+    readonly tweenEid: number;
+    readonly target: string;
+    readonly to: string;
+}
+
+let pendingXmlTweens: PendingTween[] = [];
+
+function setupTweenFromXml(
+    _state: State,
+    _context: ParseContext,
+    attrs: Record<string, string>,
+    tweenEid: number
+): void {
+    pendingXmlTweens.push({
+        tweenEid,
+        target: attrs.target,
+        to: attrs.to,
+    });
+}
+
+export function finalizePendingTweens(state: State, context: ParseContext): void {
+    for (const pending of pendingXmlTweens) {
+        const parsed = parseTargetPath(pending.target);
+        if (!parsed) continue;
+
+        const targetEid = context.getEntityByName(parsed.entity);
+        if (targetEid === null) continue;
+
+        const binding = state.bindFieldAccessor(pending.tweenEid, parsed.component, parsed.field);
+        if (!binding) continue;
+
+        state.addRelation(pending.tweenEid, TweenTarget, targetEid);
+
+        Tween.to[pending.tweenEid] = parseFloat(pending.to);
+    }
+    pendingXmlTweens = [];
+}
+
+export function captureFromValue(state: State, tweenEid: number): void {
+    const targetEid = state.getFirstRelationTarget(tweenEid, TweenTarget);
+    const binding = state.getFieldAccessor(tweenEid);
+
+    if (binding && targetEid >= 0) {
+        Tween.from[tweenEid] = binding.get(targetEid) ?? 0;
+    }
+}
+
+export function ensureResolved(state: State, tweenEid: number): void {
+    const elapsed = Tween.elapsed[tweenEid];
+    const duration = Tween.duration[tweenEid];
+
+    if (elapsed >= duration) return;
+
+    const targetEid = state.getFirstRelationTarget(tweenEid, TweenTarget);
+    const binding = state.getFieldAccessor(tweenEid);
+
+    if (binding && targetEid >= 0) {
+        Tween.from[tweenEid] = binding.get(targetEid) ?? 0;
+        binding.set(targetEid, Tween.to[tweenEid]);
+    }
+
+    Tween.elapsed[tweenEid] = duration;
+}
+
+function updateTweens(state: State, dt: number): void {
+    for (const tweenEid of state.query([Tween])) {
+        const tweenState = Tween.state[tweenEid];
+
+        if (tweenState === TweenState.COMPLETE) {
+            ensureResolved(state, tweenEid);
+            continue;
+        }
+
+        if (tweenState !== TweenState.PLAYING) continue;
+
+        const targetEid = state.getFirstRelationTarget(tweenEid, TweenTarget);
+        const binding = state.getFieldAccessor(tweenEid);
+
+        if (Tween.elapsed[tweenEid] === 0 && binding && targetEid >= 0) {
+            Tween.from[tweenEid] = binding.get(targetEid) ?? 0;
+        }
+
+        Tween.elapsed[tweenEid] += dt;
+
+        const elapsed = Tween.elapsed[tweenEid];
+        const duration = Tween.duration[tweenEid];
+        const rawProgress = Math.min(elapsed / duration, 1);
+
+        const easingFn = getEasing(Tween.easingIndex[tweenEid]);
+        const easedProgress = easingFn(rawProgress);
+
+        const from = Tween.from[tweenEid];
+        const to = Tween.to[tweenEid];
+        const value = from + (to - from) * easedProgress;
+
+        if (binding && targetEid >= 0) {
+            binding.set(targetEid, value);
+        }
+
+        if (rawProgress >= 1) {
+            Tween.state[tweenEid] = TweenState.COMPLETE;
+        }
+    }
+}
+
+export interface TweenOptions {
+    readonly to: number;
+    readonly duration?: number;
+    readonly easing?: string;
+}
+
+export function createTween(
+    state: State,
+    targetEid: number,
+    fieldPath: string,
+    options: TweenOptions
+): number | null {
+    const parsed = state.resolveFieldPath(fieldPath);
+    if (!parsed) return null;
+
+    const tweenEid = state.addEntity();
+    state.addComponent(tweenEid, Tween);
+
+    const binding = state.bindFieldAccessor(tweenEid, parsed.component, parsed.field);
+    if (!binding) {
+        state.removeEntity(tweenEid);
+        return null;
+    }
+
+    state.addRelation(tweenEid, TweenTarget, targetEid);
+
+    Tween.to[tweenEid] = options.to;
+    Tween.duration[tweenEid] = options.duration ?? 1;
+    Tween.elapsed[tweenEid] = 0;
+    Tween.easingIndex[tweenEid] = getEasingIndex(options.easing ?? "linear");
+
+    return tweenEid;
+}
+
+export const TweenSystem: System = {
+    group: "simulation",
+
+    update(state: State) {
+        const dt = state.time.deltaTime;
+
+        ensureSequencesResolved(state);
+        updateSequences(state, dt);
+        updateTweens(state, dt);
+        checkSequenceCompletion(state);
+    },
+};
+
+export const TweenPlugin: Plugin = {
+    systems: [TweenSystem],
+    components: { Tween, Sequence, Pause },
+    relations: [TweenTarget],
+    initialize() {
+        registerPostLoadHook(finalizePendingTweens);
+    },
+};

package/src/vite-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="vite/client" />
+
+declare module "*.wasm?url" {
+    const url: string;
+    export default url;
+}