@aura3d/engine 3.0.0 → 4.0.0

package/dist/engine/agent-api/GameRuntime.js

@@ -8,6 +8,9 @@
 import { Shape as PhysicsShapeFactory } from "../../physics/solverless.js";
 // Static, from the narrow entry: createGameCollisionWorld is synchronous public API. See world.ts.
 import { PhysicsWorld } from "../../physics/world.js";
+import { createGameEffects, publicGameEffectInstance, resolveEffectAttachmentPosition, defaultEffectColor, defaultEffectDuration, defaultEffectRadius, effectToSceneNode } from "./vfx/gameEffects.js";
+import { createQrGameCameraDirector } from "./camera/gameDirector.js";
+import { createBicycleModel } from "./vehicle/BicycleModel.js";
 export function createGameLoopPlan(options = {}) {
     return {
         kind: "aura-game-loop-plan",
@@ -311,7 +314,12 @@ export function createGameInput(options) {
     const actions = options.actions;
     const axes = options.axes ?? {};
     const axisDefaults = options.axisDefaults ?? {};
-    const bufferMs = options.bufferMs ?? 120;
+    const bufferMsOption = options.bufferMs ?? 120;
+    const bufferMs = typeof bufferMsOption === "number" ? bufferMsOption : 120;
+    // I-5: per-action windows — record overrides, then 130/150/120 defaults.
+    const bufferFor = (action) => typeof bufferMsOption === "object"
+        ? bufferMsOption[action] ?? 120
+        : bufferMsOption ?? (action === "jump" ? 130 : action === "attack" ? 150 : 120);
     const activeBindings = new Set();
     const activeActionOverrides = new Set();
     const pendingPressedBindings = new Set();
@@ -328,6 +336,9 @@ export function createGameInput(options) {
     let frame = 0;
     let time = 0;
     let pointer = { active: false, x: 0, y: 0, dx: 0, dy: 0, buttons: [] };
+    // E5: previous event's pointer-lock state, so the first unlocked move
+    // after exiting lock re-origins instead of spiking from a stale clientX.
+    let wasPointerLocked = false;
     let latestGamepads = [];
     let latestSnapshot = {
         kind: "aura-game-input-snapshot",
@@ -365,6 +376,11 @@ export function createGameInput(options) {
         if (shouldRecord)
             record("release", binding);
     };
+    // I-3: last device kind that produced input (for prompt()).
+    let lastDevice;
+    const markDevice = (kind) => {
+        lastDevice = kind;
+    };
     const pollGamepads = () => {
         for (const binding of gamepadBindings)
             activeBindings.delete(binding);
@@ -388,6 +404,8 @@ export function createGameInput(options) {
                     buttonNames.push(name);
                 }
             });
+            if (buttonNames.length > 0)
+                markDevice("gamepad");
             latestGamepads.push({
                 connected: true,
                 index: pad.index,
@@ -490,6 +508,7 @@ export function createGameInput(options) {
         const keyboard = event;
         if (keyboard.repeat)
             return;
+        markDevice("keyboard");
         if (keyboard.code)
             pressBinding(keyboard.code);
         if (keyboard.key && keyboard.key !== keyboard.code)
@@ -502,32 +521,46 @@ export function createGameInput(options) {
         if (keyboard.key && keyboard.key !== keyboard.code)
             releaseBinding(keyboard.key);
     };
+    // E5: under pointer lock, clientX/clientY freeze at the lock point and
+    // only movementX/movementY carry the delta — the old clientX-diff math
+    // accumulated exactly zero, so pointer-locked look could not turn.
+    const accumulatePointerDelta = (next) => {
+        const locked = typeof document !== "undefined" && document.pointerLockElement !== null;
+        let dx = pointer.dx;
+        let dy = pointer.dy;
+        if (locked) {
+            dx += Number.isFinite(next.movementX) ? next.movementX : 0;
+            dy += Number.isFinite(next.movementY) ? next.movementY : 0;
+        }
+        else if (!wasPointerLocked) {
+            dx += next.clientX - pointer.x;
+            dy += next.clientY - pointer.y;
+        }
+        wasPointerLocked = locked;
+        pointer = { ...pointer, x: next.clientX, y: next.clientY, dx, dy };
+    };
     const onPointerDown = (event) => {
         if (options.pointer === false)
             return;
         const next = event;
+        markDevice(next.pointerType === "touch" ? "touch" : "pointer");
         pressBinding(next.button === 2 ? "PointerSecondary" : "PointerPrimary");
         pressBinding(`PointerButton${next.button}`);
         pointer = {
             active: true,
             x: next.clientX,
             y: next.clientY,
-            dx: 0,
-            dy: 0,
+            // Preserve this frame's accumulated delta: a click mid-flick must not
+            // wipe the look movement already earned in the same frame.
+            dx: pointer.dx,
+            dy: pointer.dy,
             buttons: [...new Set([...pointer.buttons, next.button])].sort()
         };
     };
     const onPointerMove = (event) => {
         if (options.pointer === false)
             return;
-        const next = event;
-        pointer = {
-            ...pointer,
-            x: next.clientX,
-            y: next.clientY,
-            dx: pointer.dx + next.clientX - pointer.x,
-            dy: pointer.dy + next.clientY - pointer.y
-        };
+        accumulatePointerDelta(event);
     };
     const onPointerUp = (event) => {
         if (options.pointer === false)
@@ -535,19 +568,14 @@ export function createGameInput(options) {
         const next = event;
         releaseBinding(next.button === 2 ? "PointerSecondary" : "PointerPrimary");
         releaseBinding(`PointerButton${next.button}`);
+        accumulatePointerDelta(next);
         const buttons = pointer.buttons.filter((button) => button !== next.button);
-        pointer = {
-            active: buttons.length > 0,
-            x: next.clientX,
-            y: next.clientY,
-            dx: pointer.dx + next.clientX - pointer.x,
-            dy: pointer.dy + next.clientY - pointer.y,
-            buttons
-        };
+        pointer = { ...pointer, active: buttons.length > 0, buttons };
     };
     const onTouchStart = (event) => {
         if (options.touch === false)
             return;
+        markDevice("touch");
         const touch = event.touches[0];
         pressBinding("TouchPrimary");
         if (touch)
@@ -587,9 +615,67 @@ export function createGameInput(options) {
         released(action) {
             return releasedEdges.has(action);
         },
-        buffered(action, windowMs = bufferMs) {
+        buffered(action, windowMs = bufferFor(action)) {
             return pressedEdges.has(action) || time * 1000 - (lastPressedAt.get(action) ?? Number.NEGATIVE_INFINITY) <= windowMs;
         },
+        consume(action) {
+            const had = pressedEdges.has(action) || lastPressedAt.has(action);
+            pressedEdges.delete(action);
+            lastPressedAt.delete(action);
+            return had;
+        },
+        activeDevice() {
+            return lastDevice;
+        },
+        prompt(action, device = lastDevice) {
+            const bindings = actions[action] ?? [];
+            const deviceOf = (binding) => {
+                if (/^(pad:|gamepad)/i.test(binding))
+                    return "gamepad";
+                if (/^touch/i.test(binding))
+                    return "touch";
+                if (/^pointer/i.test(binding))
+                    return "pointer";
+                return "keyboard";
+            };
+            const gamepadLabel = (binding) => {
+                const tail = binding.replace(/^pad:/i, "");
+                const named = {
+                    GamepadA: "A", GamepadB: "B", GamepadX: "X", GamepadY: "Y",
+                    GamepadLB: "LB", GamepadRB: "RB", GamepadLT: "LT", GamepadRT: "RT",
+                    GamepadStart: "Start", GamepadBack: "Back"
+                };
+                if (named[binding])
+                    return named[binding];
+                const buttonMatch = /Button(\d+)$/.exec(binding);
+                if (buttonMatch)
+                    return `Button ${buttonMatch[1]}`;
+                return `pad-${tail.replace(/[^a-z0-9]+/gi, "-").toLowerCase()}`;
+            };
+            const pick = bindings.find((binding) => deviceOf(binding) === device);
+            if (!pick)
+                return undefined;
+            if (device === "gamepad")
+                return gamepadLabel(pick);
+            if (device === "touch") {
+                const label = pick.replace(/^touch:?/i, "");
+                return label.length > 0 && !/^touch/i.test(pick) ? label : action.charAt(0).toUpperCase() + action.slice(1);
+            }
+            return pick;
+        },
+        touch: {
+            press(binding) {
+                markDevice("touch");
+                pressBinding(binding);
+            },
+            release(binding) {
+                releaseBinding(binding);
+            },
+            setAxis(name, value) {
+                markDevice("touch");
+                axisValues.set(name, clamp(value, -1, 1));
+            }
+        },
         combo(sequence, windowMs = bufferMs * Math.max(1, sequence.length)) {
             if (sequence.length === 0)
                 return false;
@@ -666,7 +752,79 @@ export function createGameInput(options) {
         }
     };
 }
+/** V-2/V-3/V-4: "bicycle" delegates to the V-1 slip-angle BicycleModel. */
+function createBicycleArcadeVehicle(options) {
+    const maxSpeed = Math.max(0.001, options.maxSpeed);
+    const model = createBicycleModel({
+        maxSpeed,
+        mass: options.mass,
+        cgToFront: options.cgToFront,
+        cgToRear: options.cgToRear,
+        yawInertia: options.yawInertia,
+        maxSteer: options.maxSteer,
+        steerReferenceSpeed: options.steerReferenceSpeed,
+        tyre: options.tyre,
+        handbrakeRearGrip: options.handbrakeRearGrip,
+        dragCoefficient: options.dragCoefficient,
+        rollingResistance: options.rollingResistance,
+        torqueCurve: options.torqueCurve,
+        steerAssist: options.steerAssist
+    });
+    // Heading conventions differ: GameArcadeVehicle (and every racing kit,
+    // surface query and chassis) moves along (cos h, sin h) on the (x, z) plane,
+    // while BicycleModel moves along (sin h, cos h). The two are mirror images
+    // (h_model = PI/2 - h), so heading, steer and every signed lateral/yaw
+    // quantity cross this adapter mirrored. Passing headings straight through
+    // drove the car at 90 degrees to its heading (sideways off the track).
+    const toModelHeading = (heading) => Math.PI / 2 - heading;
+    const snapshot = () => {
+        const s = model.snapshot();
+        return {
+            x: s.x,
+            z: s.z,
+            heading: toModelHeading(s.heading),
+            speed: s.vLong,
+            drift: Math.min(1, Math.abs(s.rearSlipAngle) / 0.12),
+            lateralVelocity: -s.vLat,
+            yawRate: -s.yawRate,
+            slipAngle: -s.slipAngle,
+            drifting: s.drifting,
+            rpm: s.rpm,
+            lateralG: -s.lateralG
+        };
+    };
+    return {
+        kind: "aura-game-arcade-vehicle",
+        step(dt, input = {}) {
+            model.step(clamp(dt, 0, 0.05), {
+                steer: -clamp(input.steer ?? 0, -1, 1),
+                throttle: input.throttle,
+                brake: input.brake,
+                handbrake: input.handbrake === true || input.drifting === true
+            });
+            return snapshot();
+        },
+        constrain(constraint) {
+            model.setPoseState({
+                x: constraint.x,
+                z: constraint.z,
+                heading: constraint.heading === undefined ? undefined : toModelHeading(constraint.heading)
+            });
+            const speedScale = Math.max(0, constraint.speedMultiplier ?? 1);
+            model.scaleVelocity(speedScale * clamp(constraint.driftMultiplier ?? 1, 0.5, 1));
+            return snapshot();
+        },
+        reset(next = {}) {
+            model.reset({ x: next.x, z: next.z, heading: toModelHeading(next.heading ?? 0) });
+            model.setVelocity(next.speed ?? 0);
+            return snapshot();
+        },
+        snapshot
+    };
+}
 export function createGameArcadeVehicle(options) {
+    if (options.model === "bicycle")
+        return createBicycleArcadeVehicle(options);
     const maxSpeed = Math.max(0.001, options.maxSpeed);
     const acceleration = options.acceleration ?? 16;
     const brakeStrength = options.brakeStrength ?? 24;
@@ -731,6 +889,14 @@ export function createGameArcadeVehicle(options) {
 export function createGameKinematicBody(options = {}) {
     let position = vec3(options.position, [0, options.groundY ?? 0, 0]);
     let velocity = vec3(options.velocity, [0, 0, 0]);
+    // P-1 (§6.9): accel-limited horizontal movement under A3D_QR_CAMERA.
+    // `move` records the intent; updateBody integrates vx toward it.
+    const accelOn = options.instantVelocity !== true && options.flags?.on("A3D_QR_CAMERA") === true;
+    const groundAccel = options.groundAccel ?? 60;
+    const groundDecel = options.groundDecel ?? 70;
+    const turnAccel = options.turnAccel ?? 110;
+    const airControl = options.airControl ?? 0.65;
+    let targetVx;
     const size = vec3(options.size ?? kinematicSizeFromCollider(options.collider), [0.72, 1.7, 0.42]);
     const gravity = typeof options.gravity === "boolean" ? (options.gravity ? -18 : 0) : options.gravity ?? -18;
     const groundY = options.groundY ?? 0;
@@ -805,7 +971,20 @@ export function createGameKinematicBody(options = {}) {
         else {
             grounded = false;
         }
-        if (grounded && friction > 0) {
+        if (accelOn && targetVx !== undefined) {
+            const current = velocity[0];
+            const reversing = Math.sign(targetVx) !== Math.sign(current) && Math.abs(current) > 0.01 && Math.abs(targetVx) > 0.01;
+            const rate = !grounded
+                ? groundAccel * airControl
+                : reversing
+                    ? turnAccel
+                    : Math.abs(targetVx) > Math.abs(current)
+                        ? groundAccel
+                        : groundDecel;
+            const dv = clamp(targetVx - current, -rate * seconds, rate * seconds);
+            velocity = [current + dv, velocity[1], velocity[2]];
+        }
+        else if (grounded && friction > 0) {
             const damping = Math.max(0, 1 - friction * seconds);
             velocity = [velocity[0] * damping, velocity[1], velocity[2] * damping];
         }
@@ -842,7 +1021,13 @@ export function createGameKinematicBody(options = {}) {
         move(axisOrCommand, speedOrDt) {
             if (typeof axisOrCommand === "number") {
                 const next = clamp(axisOrCommand, -1, 1);
-                velocity = [next * (speedOrDt ?? maxSpeed), velocity[1], velocity[2]];
+                const target = next * (speedOrDt ?? maxSpeed);
+                if (accelOn) {
+                    targetVx = target;
+                }
+                else {
+                    velocity = [target, velocity[1], velocity[2]];
+                }
                 if (Math.abs(next) > 0.01)
                     facing = next >= 0 ? 1 : -1;
                 return undefined;
@@ -853,11 +1038,21 @@ export function createGameKinematicBody(options = {}) {
                 : command.x !== undefined
                     ? clamp(command.x, -maxSpeed, maxSpeed)
                     : velocity[0];
-            velocity = [
-                horizontal,
-                command.y !== undefined ? command.y : velocity[1],
-                command.z !== undefined ? clamp(command.z, -maxSpeed, maxSpeed) : velocity[2]
-            ];
+            if (accelOn) {
+                targetVx = horizontal;
+                velocity = [
+                    velocity[0],
+                    command.y !== undefined ? command.y : velocity[1],
+                    command.z !== undefined ? clamp(command.z, -maxSpeed, maxSpeed) : velocity[2]
+                ];
+            }
+            else {
+                velocity = [
+                    horizontal,
+                    command.y !== undefined ? command.y : velocity[1],
+                    command.z !== undefined ? clamp(command.z, -maxSpeed, maxSpeed) : velocity[2]
+                ];
+            }
             if (Math.abs(horizontal) > 0.01)
                 facing = horizontal >= 0 ? 1 : -1;
             if (command.jump) {
@@ -1388,6 +1583,12 @@ export function createCombatWorld(options = {}) {
     return controller;
 }
 export function createGameCameraDirector(options = {}) {
+    // R-12: flag-on returns a real camera-controller director (rigs.fighting +
+    // shake layer); it structurally implements GameCameraDirector and adds
+    // `bind(app)` for presenting through `app.camera.setPose`.
+    if (options.legacySpec !== true && options.flags?.on("A3D_QR_CAMERA") === true) {
+        return createQrGameCameraDirector(options);
+    }
     const baseFov = options.baseFov ?? 42;
     const baseDistance = options.distance ?? 6.2;
     const targetY = options.targetY ?? 0.95;
@@ -1453,103 +1654,29 @@ export function createGameCameraDirector(options = {}) {
         }
     };
 }
-export function createGameEffects(options = {}) {
-    const poolSize = options.poolSize ?? 96;
-    const reducedMotion = options.reducedMotion ?? false;
-    const reducedFlash = options.reducedFlash ?? false;
-    let spawned = 0;
-    let effects = [];
-    const snapshot = () => ({
-        kind: "aura-game-effects",
-        active: effects.length,
-        spawned,
-        pooled: poolSize,
-        reducedMotion,
-        reducedFlash,
-        effects: effects.map(publicGameEffectInstance)
-    });
-    const spawn = (kind, position, effectOptions = {}) => {
-        spawned += 1;
-        const flashLimited = reducedFlash && (kind === "impact-flash" || kind === "super-flash");
-        const motionLimited = reducedMotion && (kind === "dash-trail" || kind === "slash-trail" || kind === "shockwave" || kind === "ring-shockwave");
-        const attachment = effectOptions.attachment;
-        const effect = {
-            id: effectOptions.ownerId ? `${effectOptions.ownerId}:${kind}:${spawned}` : `${kind}:${spawned}`,
-            kind,
-            position: resolveEffectAttachmentPosition(attachment, position),
-            color: effectOptions.color ?? defaultEffectColor(kind),
-            intensity: Math.min(effectOptions.intensity ?? 1, flashLimited ? 0.35 : motionLimited ? 0.55 : Number.POSITIVE_INFINITY),
-            duration: Math.min(effectOptions.duration ?? defaultEffectDuration(kind), motionLimited ? 0.18 : Number.POSITIVE_INFINITY),
-            radius: effectOptions.radius ?? defaultEffectRadius(kind),
-            ownerId: effectOptions.ownerId,
-            attachmentId: attachment?.targetId ?? attachment?.id,
-            attachmentOffset: attachment?.offset,
-            attachment,
-            age: 0
-        };
-        if (effects.length >= poolSize)
-            effects.shift();
-        effects.push(effect);
-        return publicGameEffectInstance(effect);
-    };
-    return {
-        spawn,
-        emit(combatEvents, effectOptions) {
-            const emitted = [];
-            for (const event of combatEvents) {
-                if (event.type === "hit")
-                    emitted.push(spawn("hit-spark", event.position, { ownerId: event.attackerId, ...effectOptions }));
-                if (event.type === "blocked")
-                    emitted.push(spawn("block-spark", event.position, { ownerId: event.attackerId, ...effectOptions }));
-                if (event.type === "push")
-                    emitted.push(spawn("ground-dust", event.position, { ownerId: event.attackerId, intensity: 0.45, duration: 0.14, ...effectOptions }));
-            }
-            return emitted;
-        },
-        hitSpark: (position, effectOptions) => spawn("hit-spark", position, effectOptions),
-        blockSpark: (position, effectOptions) => spawn("block-spark", position, effectOptions),
-        impactDecal: (position, effectOptions) => spawn("impact-decal", position, effectOptions),
-        groundDust: (position, effectOptions) => spawn("ground-dust", position, effectOptions),
-        dashTrail: (position, effectOptions) => spawn("dash-trail", position, effectOptions),
-        slashTrail: (position, effectOptions) => spawn("slash-trail", position, effectOptions),
-        impactFlash: (position, effectOptions) => spawn("impact-flash", position, effectOptions),
-        auraBurst: (position, effectOptions) => spawn("aura-burst", position, effectOptions),
-        shockwave: (position, effectOptions) => spawn("shockwave", position, effectOptions),
-        ringShockwave: (position, effectOptions) => spawn("ring-shockwave", position, effectOptions),
-        superFlash: (position, effectOptions) => spawn("super-flash", position, effectOptions),
-        update(dt) {
-            const seconds = Math.max(0, dt);
-            effects = effects
-                .map((effect) => ({
-                ...effect,
-                position: resolveEffectAttachmentPosition(effect.attachment, effect.position),
-                age: effect.age + seconds
-            }))
-                .filter((effect) => effect.age <= effect.duration);
-            return snapshot();
-        },
-        snapshot,
-        nodes() {
-            return effects.map(effectToSceneNode);
-        },
-        clear() {
-            effects = [];
-        }
-    };
-}
+export { createGameEffects } from "./vfx/gameEffects.js";
 export function applyGameCombatEventsToRuntime(events, options = {}) {
     const effectIds = [];
     let cameraImpacts = 0;
+    const forwardHitStop = (event) => {
+        if (options.autoHitStop === false || !options.time || !event.hitStop || event.hitStop <= 0)
+            return;
+        options.time.hitStop(event.hitStop, {
+            scope: event.targetId ? [event.attackerId, event.targetId] : [event.attackerId]
+        });
+    };
     for (const event of events) {
         if (event.type === "hit") {
             const effect = options.effects?.hitSpark(event.position, { ownerId: event.attackerId });
             if (effect)
                 effectIds.push(effect.id);
+            forwardHitStop(event);
             options.camera?.impact(1.1);
             if (options.camera)
                 cameraImpacts += 1;
         }
         else if (event.type === "blocked") {
+            forwardHitStop(event);
             const effect = options.effects?.blockSpark(event.position, { ownerId: event.attackerId });
             if (effect)
                 effectIds.push(effect.id);
@@ -1949,15 +2076,6 @@ export function createGameDebugSceneNodes(debug, options = {}) {
     }));
     return [...primitives, ...labels];
 }
-function publicGameEffectInstance(effect) {
-    const { attachment: _attachment, ...publicEffect } = effect;
-    return { ...publicEffect };
-}
-function resolveEffectAttachmentPosition(attachment, fallback) {
-    if (!attachment?.getPosition)
-        return fallback;
-    return addVec3(attachment.getPosition(), vec3(attachment.offset, [0, 0, 0]));
-}
 function normalizeActor(actor) {
     return {
         id: actor.id,
@@ -2316,7 +2434,7 @@ function intersects(a, b) {
         a.min[2] <= b.max[2] &&
         a.max[2] >= b.min[2]);
 }
-function vec3(value, fallback) {
+export function vec3(value, fallback) {
     return value ? [value[0], value[1], value[2]] : fallback;
 }
 function vec3Flexible(value, fallback) {
@@ -2337,7 +2455,7 @@ function kinematicSizeFromCollider(collider) {
         return undefined;
     return gameColliderAabb(collider).size;
 }
-function addVec3(a, b) {
+export function addVec3(a, b) {
     return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
 }
 function scaleVec3(value, scale) {
@@ -2357,7 +2475,7 @@ function clampVec3ToBounds(value, bounds) {
         clamp(value[2], bounds.minZ ?? Number.NEGATIVE_INFINITY, bounds.maxZ ?? Number.POSITIVE_INFINITY)
     ];
 }
-function round(value, places) {
+export function round(value, places) {
     const scale = 10 ** places;
     return Math.round(value * scale) / scale;
 }
@@ -2391,99 +2509,6 @@ function gamepadButtonNames(index, gamepadIndex) {
     ];
     return [`GamepadButton${index}`, `Gamepad${gamepadIndex}:Button${index}`, names[index] ?? `GamepadButton${index}`];
 }
-function defaultEffectColor(kind) {
-    if (kind === "block-spark")
-        return "#8ee7ff";
-    if (kind === "impact-decal")
-        return "#ff8b5c";
-    if (kind === "ground-dust")
-        return "#c7b38f";
-    if (kind === "dash-trail")
-        return "#62f6c8";
-    if (kind === "slash-trail")
-        return "#d7fbff";
-    if (kind === "aura-burst")
-        return "#5cff87";
-    if (kind === "shockwave" || kind === "ring-shockwave")
-        return "#ffd166";
-    if (kind === "impact-flash" || kind === "super-flash")
-        return "#ffffff";
-    return "#ffb84d";
-}
-function defaultEffectDuration(kind) {
-    if (kind === "impact-decal")
-        return 0.7;
-    if (kind === "ground-dust")
-        return 0.34;
-    if (kind === "dash-trail")
-        return 0.28;
-    if (kind === "slash-trail")
-        return 0.18;
-    if (kind === "aura-burst")
-        return 0.9;
-    if (kind === "shockwave" || kind === "ring-shockwave")
-        return 0.42;
-    if (kind === "impact-flash")
-        return 0.12;
-    if (kind === "super-flash")
-        return 0.2;
-    return 0.22;
-}
-function defaultEffectRadius(kind) {
-    if (kind === "impact-decal")
-        return 0.42;
-    if (kind === "aura-burst")
-        return 1.4;
-    if (kind === "shockwave" || kind === "ring-shockwave")
-        return 1.05;
-    if (kind === "dash-trail")
-        return 0.52;
-    if (kind === "slash-trail")
-        return 0.62;
-    if (kind === "ground-dust")
-        return 0.36;
-    if (kind === "super-flash")
-        return 1.2;
-    return 0.28;
-}
-function effectToSceneNode(effect) {
-    const life = Math.max(0, 1 - effect.age / Math.max(0.001, effect.duration));
-    const ring = effect.kind === "shockwave" || effect.kind === "ring-shockwave";
-    const trail = effect.kind === "dash-trail" || effect.kind === "slash-trail";
-    const scalarScale = Math.max(0.04, effect.radius * (ring ? 1.4 - life * 0.4 : life));
-    const trailScale = [
-        Math.max(0.08, effect.radius * life * 1.6),
-        Math.max(0.02, effect.radius * life * 0.18),
-        Math.max(0.04, effect.radius * life * 0.32)
-    ];
-    if (effect.kind === "aura-burst") {
-        return {
-            kind: "effect",
-            effect: "particles",
-            name: effect.id,
-            color: effect.color,
-            intensity: effect.intensity * life,
-            particleCount: Math.round(160 + effect.intensity * 220),
-            emitter: "swirl",
-            radius: effect.radius,
-            height: 1.4,
-            materialMode: "additive-glow"
-        };
-    }
-    return {
-        kind: "primitive",
-        primitive: ring ? "torus" : trail ? "box" : "sphere",
-        name: effect.id,
-        position: effect.position,
-        scale: trail ? trailScale : scalarScale,
-        material: {
-            color: effect.color,
-            emissive: effect.color,
-            emissiveIntensity: effect.intensity * life,
-            opacity: life
-        }
-    };
-}
 export function createGameEventLog(options = {}) {
     const label = options.label ?? "game events";
     const maxEvents = Math.max(1, options.maxEvents ?? 64);