@aura3d/engine 1.3.2 → 1.4.0

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

@@ -1,3 +1,4 @@
+import { PhysicsWorld, Shape as PhysicsShapeFactory } from "../../physics/index.js";
 export function createGameLoopPlan(options = {}) {
     return {
         kind: "aura-game-loop-plan",
@@ -304,6 +305,8 @@ export function createGameInput(options) {
     const bufferMs = options.bufferMs ?? 120;
     const activeBindings = new Set();
     const activeActionOverrides = new Set();
+    const pendingPressedBindings = new Set();
+    const pendingPressedActions = new Set();
     const previousHeld = new Map();
     const currentHeld = new Map();
     const pressedEdges = new Set();
@@ -339,8 +342,11 @@ export function createGameInput(options) {
     };
     const pressBinding = (binding, shouldRecord = true) => {
         activeBindings.add(binding);
-        if (actions[binding])
+        pendingPressedBindings.add(binding);
+        if (actions[binding]) {
             activeActionOverrides.add(binding);
+            pendingPressedActions.add(binding);
+        }
         if (shouldRecord)
             record("press", binding);
     };
@@ -443,8 +449,9 @@ export function createGameInput(options) {
         for (const action of Object.keys(actions)) {
             const held = resolveHeld(action);
             const wasHeld = previousHeld.get(action) ?? false;
+            const pendingPressed = pendingPressedActions.has(action) || (actions[action] ?? []).some((binding) => pendingPressedBindings.has(binding));
             currentHeld.set(action, held);
-            if (held && !wasHeld) {
+            if ((held && !wasHeld) || pendingPressed) {
                 pressedEdges.add(action);
                 const nowMs = time * 1000;
                 lastPressedAt.set(action, nowMs);
@@ -456,6 +463,8 @@ export function createGameInput(options) {
                 releasedEdges.add(action);
             previousHeld.set(action, held);
         }
+        pendingPressedBindings.clear();
+        pendingPressedActions.clear();
         const axesSnapshot = {};
         for (const axisName of Object.keys(axes)) {
             const raw = resolveAxisRaw(axisName, undefined, undefined, framePointer);
@@ -598,6 +607,7 @@ export function createGameInput(options) {
         setAction(action, held) {
             if (held) {
                 activeActionOverrides.add(action);
+                pendingPressedActions.add(action);
                 record("press", action);
             }
             else {
@@ -635,6 +645,8 @@ export function createGameInput(options) {
             }
             activeBindings.clear();
             activeActionOverrides.clear();
+            pendingPressedBindings.clear();
+            pendingPressedActions.clear();
             previousHeld.clear();
             currentHeld.clear();
             pressedEdges.clear();
@@ -836,6 +848,245 @@ export function createGameKinematicBody(options = {}) {
         snapshot
     };
 }
+export function createGameCollisionWorld(descriptor = {}) {
+    let world = new PhysicsWorld(descriptor);
+    const handlesById = new Map();
+    const handlesByBodyId = new Map();
+    const handlesByColliderId = new Map();
+    let lastEvents = [];
+    const register = (handle) => {
+        handlesById.set(handle.id, handle);
+        handlesByBodyId.set(handle.body.id, handle);
+        handlesByColliderId.set(handle.collider.id, handle);
+        return handle;
+    };
+    const createHandle = (id, tags, body, collider) => {
+        const snapshot = () => ({
+            id,
+            bodyId: body.id,
+            colliderId: collider.id,
+            type: body.type,
+            position: toGameVec3(body.position),
+            velocity: toGameVec3(body.velocity),
+            shape: collider.shape,
+            sensor: collider.sensor,
+            tags,
+            layer: collider.filter.layer,
+            mask: collider.filter.mask
+        });
+        return {
+            kind: "aura-game-collision-body",
+            id,
+            body,
+            collider,
+            tags,
+            get position() {
+                return toGameVec3(body.position);
+            },
+            get velocity() {
+                return toGameVec3(body.velocity);
+            },
+            setPosition(position) {
+                body.setPosition(vec3(position, body.position));
+                return snapshot();
+            },
+            setVelocity(velocity) {
+                body.setVelocity(vec3(velocity, body.velocity));
+                return snapshot();
+            },
+            translate(delta) {
+                body.setPosition(addVec3(body.position, vec3(delta, [0, 0, 0])));
+                return snapshot();
+            },
+            snapshot
+        };
+    };
+    const add = (options) => {
+        const id = options.id.trim();
+        if (!id) {
+            throw new Error("game.collisionWorld body id must be a non-empty string.");
+        }
+        if (handlesById.has(id)) {
+            throw new Error(`game.collisionWorld already has a body named '${id}'.`);
+        }
+        const body = world.createRigidBody({
+            ...options.rigidBody,
+            type: options.type ?? "dynamic",
+            position: vec3(options.position, [0, 0, 0]),
+            velocity: vec3(options.velocity, [0, 0, 0])
+        });
+        const collider = world.createCollider(body, {
+            shape: options.shape ?? PhysicsShapeFactory.box(0.5, 0.5, 0.5),
+            sensor: options.sensor ?? false,
+            filter: {
+                layer: options.layer ?? 1,
+                mask: options.mask ?? 0xffffffff
+            },
+            material: options.material
+        });
+        return register(createHandle(id, [...(options.tags ?? [])], body, collider));
+    };
+    const requireBody = (id) => {
+        const handle = handlesById.get(id);
+        if (!handle) {
+            throw new Error(`game.collisionWorld missing body '${id}'.`);
+        }
+        return handle;
+    };
+    const mapContact = (contact, type) => {
+        const a = handlesByColliderId.get(contact.colliderA);
+        const b = handlesByColliderId.get(contact.colliderB);
+        if (!a || !b) {
+            return undefined;
+        }
+        return {
+            kind: "aura-game-collision-contact",
+            pairKey: gameCollisionPairKey(contact.colliderA, contact.colliderB),
+            type,
+            a: gameCollisionParticipant(a),
+            b: gameCollisionParticipant(b),
+            normal: toGameVec3(contact.normal),
+            penetration: contact.penetration,
+            sensor: contact.sensor,
+            contact
+        };
+    };
+    const mapEvent = (event) => {
+        const contact = mapContact(event.contact, event.type);
+        if (!contact) {
+            return undefined;
+        }
+        return {
+            ...contact,
+            type: event.type
+        };
+    };
+    const currentContacts = (filter = {}) => {
+        const contacts = [];
+        for (const contact of world.snapshot().contacts) {
+            const mapped = mapContact(contact);
+            if (mapped && gameCollisionContactMatchesFilter(mapped, filter)) {
+                contacts.push(mapped);
+            }
+        }
+        return contacts;
+    };
+    return {
+        kind: "aura-game-collision-world",
+        add,
+        addBox(id, halfExtents, options = {}) {
+            return add({
+                ...options,
+                id,
+                shape: PhysicsShapeFactory.box(halfExtents[0], halfExtents[1], halfExtents[2])
+            });
+        },
+        addSphere(id, radius, options = {}) {
+            return add({
+                ...options,
+                id,
+                shape: PhysicsShapeFactory.sphere(radius)
+            });
+        },
+        addCapsule(id, radius, halfHeight, options = {}) {
+            return add({
+                ...options,
+                id,
+                shape: PhysicsShapeFactory.capsule(radius, halfHeight)
+            });
+        },
+        get(id) {
+            return handlesById.get(id);
+        },
+        require: requireBody,
+        remove(id) {
+            const handle = handlesById.get(id);
+            if (!handle) {
+                return false;
+            }
+            handlesById.delete(id);
+            handlesByBodyId.delete(handle.body.id);
+            handlesByColliderId.delete(handle.collider.id);
+            world.removeRigidBody(handle.body.id);
+            return true;
+        },
+        clear() {
+            world = new PhysicsWorld(descriptor);
+            handlesById.clear();
+            handlesByBodyId.clear();
+            handlesByColliderId.clear();
+            lastEvents = [];
+        },
+        step(dt) {
+            const events = dt === undefined ? world.step() : world.step(dt);
+            lastEvents = events.map(mapEvent).filter(isDefined);
+            return lastEvents;
+        },
+        events(filter = {}) {
+            return lastEvents.filter((event) => gameCollisionContactMatchesFilter(event, filter));
+        },
+        overlaps: currentContacts,
+        sweep(id, direction, distance, options = {}) {
+            const source = requireBody(id);
+            if (!Number.isFinite(distance) || distance <= 0) {
+                throw new Error("game.collisionWorld.sweep distance must be a finite positive number.");
+            }
+            const castRadius = options.radius ?? gameCollisionSweepRadius(source.collider.shape);
+            const hits = world.sphereCastAll(source.body.position, castRadius, direction, {
+                maxDistance: distance,
+                mask: options.mask ?? source.collider.filter.mask,
+                includeSensors: options.includeSensors ?? true,
+                includeBackfaces: options.includeBackfaces
+            });
+            const sourceParticipant = gameCollisionParticipant(source);
+            const mapped = [];
+            for (const hit of hits) {
+                if (options.includeSelf !== true && hit.colliderId === source.collider.id) {
+                    continue;
+                }
+                const target = handlesByColliderId.get(hit.colliderId);
+                if (!target || !gameCollisionParticipantMatchesFilter(target, options)) {
+                    continue;
+                }
+                mapped.push({
+                    kind: "aura-game-collision-sweep-hit",
+                    source: sourceParticipant,
+                    target: gameCollisionParticipant(target),
+                    point: toGameVec3(hit.point),
+                    normal: toGameVec3(hit.normal),
+                    distance: hit.distance,
+                    castCenter: toGameVec3(hit.castCenter),
+                    castRadius: hit.castRadius,
+                    hit
+                });
+            }
+            return mapped;
+        },
+        resolve(id, filter = {}) {
+            const handle = requireBody(id);
+            let position = handle.position;
+            for (const contact of currentContacts({ ...filter, includeSensors: false })) {
+                if (contact.contact.colliderA !== handle.collider.id && contact.contact.colliderB !== handle.collider.id) {
+                    continue;
+                }
+                const direction = contact.contact.colliderA === handle.collider.id ? -1 : 1;
+                const correction = scaleVec3(contact.normal, direction * (contact.penetration + 0.0001));
+                position = addVec3(position, correction);
+            }
+            handle.body.setPosition(position);
+            return handle.snapshot();
+        },
+        snapshot() {
+            const physicsSnapshot = world.snapshot();
+            return {
+                kind: "aura-game-collision-world",
+                bodies: Array.from(handlesById.values()).map((handle) => handle.snapshot()),
+                contacts: currentContacts(),
+                stats: physicsSnapshot.stats
+            };
+        }
+    };
+}
 export function createGameFighting2DRules(options = {}) {
     return {
         kind: "aura-game-fighting-2d-rules",
@@ -1683,6 +1934,66 @@ function syncBodiesFromActors(bodies, actors) {
             body.position = actor.position;
     }
 }
+function gameCollisionParticipant(handle) {
+    return {
+        id: handle.id,
+        bodyId: handle.body.id,
+        colliderId: handle.collider.id,
+        type: handle.body.type,
+        position: handle.position,
+        tags: handle.tags,
+        sensor: handle.collider.sensor,
+        layer: handle.collider.filter.layer,
+        mask: handle.collider.filter.mask
+    };
+}
+function gameCollisionPairKey(colliderA, colliderB) {
+    return colliderA < colliderB ? `${colliderA}:${colliderB}` : `${colliderB}:${colliderA}`;
+}
+function gameCollisionSweepRadius(shape) {
+    if (shape.kind === "sphere")
+        return shape.radius;
+    if (shape.kind === "capsule")
+        return shape.radius;
+    if (shape.kind === "box")
+        return Math.max(0.05, Math.min(shape.halfExtents[0], shape.halfExtents[1], shape.halfExtents[2]));
+    return 0.1;
+}
+function gameCollisionContactMatchesFilter(contact, filter) {
+    if (filter.includeSensors === false && contact.sensor)
+        return false;
+    if (filter.includeSolids === false && !contact.sensor)
+        return false;
+    if (filter.ids?.length && !filter.ids.includes(contact.a.id) && !filter.ids.includes(contact.b.id))
+        return false;
+    if (filter.tags?.length && !hasAnyGameTag(contact.a.tags, filter.tags) && !hasAnyGameTag(contact.b.tags, filter.tags))
+        return false;
+    if (filter.layerMask !== undefined && (contact.a.layer & filter.layerMask) === 0 && (contact.b.layer & filter.layerMask) === 0)
+        return false;
+    return true;
+}
+function gameCollisionParticipantMatchesFilter(handle, filter) {
+    if (filter.includeSensors === false && handle.collider.sensor)
+        return false;
+    if (filter.includeSolids === false && !handle.collider.sensor)
+        return false;
+    if (filter.ids?.length && !filter.ids.includes(handle.id))
+        return false;
+    if (filter.tags?.length && !hasAnyGameTag(handle.tags, filter.tags))
+        return false;
+    if (filter.layerMask !== undefined && (handle.collider.filter.layer & filter.layerMask) === 0)
+        return false;
+    return true;
+}
+function hasAnyGameTag(source, expected) {
+    return expected.some((tag) => source.includes(tag));
+}
+function toGameVec3(value) {
+    return [value[0], value[1], value[2]];
+}
+function isDefined(value) {
+    return value !== undefined;
+}
 function resolvePushboxSeparation(actors, stageBounds, frame, time, events) {
     const actorList = [...actors.values()];
     for (let leftIndex = 0; leftIndex < actorList.length; leftIndex += 1) {
@@ -2086,6 +2397,52 @@ function effectToSceneNode(effect) {
         }
     };
 }
+export function createGameEventLog(options = {}) {
+    const label = options.label ?? "game events";
+    const maxEvents = Math.max(1, options.maxEvents ?? 64);
+    let sequence = 0;
+    let records = [];
+    const snapshot = () => ({
+        kind: "aura-game-event-log",
+        label,
+        count: records.length,
+        events: [...records],
+        types: [...new Set(records.map((event) => event.type))].sort(),
+        last: records[records.length - 1]
+    });
+    return {
+        kind: "aura-game-event-log",
+        push(event) {
+            sequence += 1;
+            const record = {
+                kind: "aura-game-event",
+                id: `${event.type}:${sequence}`,
+                type: event.type,
+                label: event.label ?? event.type,
+                targetId: event.targetId,
+                value: event.value,
+                tags: [...(event.tags ?? [])],
+                severity: event.severity ?? "info",
+                frame: event.frame ?? sequence,
+                time: event.time ?? 0
+            };
+            records = [...records, record].slice(-maxEvents);
+            return record;
+        },
+        events() {
+            return [...records];
+        },
+        consume() {
+            const consumed = [...records];
+            records = [];
+            return consumed;
+        },
+        clear() {
+            records = [];
+        },
+        snapshot
+    };
+}
 export function createGameHudHealthBinding(options) {
     return createGameHudBinding({
         binding: "health",
@@ -2166,6 +2523,78 @@ export function createGameHudDebugToggleBinding(options = {}) {
         visibleWhen: options.visibleWhen ?? options.action
     });
 }
+export function createGameHudValueBinding(options) {
+    return createGameHudBinding({
+        binding: options.binding ?? "value",
+        id: options.id ?? `hud:${options.binding ?? "value"}:${options.valuePath.replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "")}`,
+        label: options.label ?? options.binding ?? "value",
+        source: options.source ?? "app-state",
+        targetId: options.targetId,
+        valuePath: options.valuePath,
+        maxPath: options.maxPath,
+        format: options.format ?? "text",
+        a11yLabel: options.a11yLabel ?? options.label ?? options.binding ?? "value",
+        debugOnly: options.debugOnly,
+        interactive: options.interactive,
+        visibleWhen: options.visibleWhen
+    });
+}
+export function createGameHudScoreBinding(options = {}) {
+    return createGameHudValueBinding({
+        ...options,
+        binding: "score",
+        id: options.id ?? "hud:score",
+        label: options.label ?? "score",
+        valuePath: options.valuePath ?? "appState.score",
+        format: options.format ?? "number",
+        a11yLabel: options.a11yLabel ?? "score"
+    });
+}
+export function createGameHudLivesBinding(options = {}) {
+    return createGameHudValueBinding({
+        ...options,
+        binding: "lives",
+        id: options.id ?? "hud:lives",
+        label: options.label ?? "lives",
+        valuePath: options.valuePath ?? "appState.lives",
+        format: options.format ?? "number",
+        a11yLabel: options.a11yLabel ?? "lives remaining"
+    });
+}
+export function createGameHudObjectiveBinding(options = {}) {
+    return createGameHudValueBinding({
+        ...options,
+        binding: "objective",
+        id: options.id ?? "hud:objective",
+        label: options.label ?? "objective",
+        valuePath: options.valuePath ?? "appState.objective",
+        format: options.format ?? "text",
+        a11yLabel: options.a11yLabel ?? "current objective"
+    });
+}
+export function createGameHudCheckpointBinding(options = {}) {
+    return createGameHudValueBinding({
+        ...options,
+        binding: "checkpoint",
+        id: options.id ?? "hud:checkpoint",
+        label: options.label ?? "checkpoint",
+        valuePath: options.valuePath ?? "appState.checkpoint",
+        format: options.format ?? "text",
+        a11yLabel: options.a11yLabel ?? "current checkpoint"
+    });
+}
+export function createGameHudEventLogBinding(options = {}) {
+    return createGameHudValueBinding({
+        ...options,
+        binding: "event-log",
+        id: options.id ?? "hud:event-log",
+        label: options.label ?? "event log",
+        valuePath: options.valuePath ?? "appState.events",
+        format: options.format ?? "text",
+        a11yLabel: options.a11yLabel ?? "game event log",
+        debugOnly: options.debugOnly ?? true
+    });
+}
 export function createGameHudBindings(bindings) {
     return [...bindings];
 }