@aura3d/engine 1.5.1 → 2.0.0

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

@@ -1,4 +1,13 @@
-import { PhysicsWorld, Shape as PhysicsShapeFactory } from "../../physics/index.js";
+/*
+ * Solver-free values from the geometry/query entry; physical simulation is isolated.
+ *
+ * `Shape` is pure data, so it comes statically. `PhysicsWorld` is loaded by
+ * `loadGameCollisionSolver()` below, because importing it here made every consumer of the game
+ * runtime — including a scene with no bodies — download or initialize Rapier.
+ */
+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";
 export function createGameLoopPlan(options = {}) {
     return {
         kind: "aura-game-loop-plan",
@@ -657,6 +666,65 @@ export function createGameInput(options) {
         }
     };
 }
+export function createGameArcadeVehicle(options) {
+    const maxSpeed = Math.max(0.001, options.maxSpeed);
+    const acceleration = options.acceleration ?? 16;
+    const brakeStrength = options.brakeStrength ?? 24;
+    const reverseSpeed = options.reverseSpeed ?? 4;
+    const drag = options.drag ?? 2.4;
+    const steerRate = options.steerRate ?? 2.7;
+    const boostAcceleration = options.boostAcceleration ?? 9;
+    let state = { x: 0, z: 0, heading: 0, speed: 0, drift: 0 };
+    const snapshot = () => ({ ...state });
+    return {
+        kind: "aura-game-arcade-vehicle",
+        step(dt, input = {}) {
+            const seconds = clamp(dt, 0, 0.05);
+            let speed = state.speed
+                + clamp(input.throttle ?? 0, 0, 1) * acceleration * seconds
+                - clamp(input.brake ?? 0, 0, 1) * brakeStrength * seconds;
+            if (input.boost && state.drift > 0.18)
+                speed += boostAcceleration * seconds;
+            speed -= Math.sign(speed) * Math.min(Math.abs(speed), drag * seconds);
+            speed = clamp(speed, -reverseSpeed, maxSpeed);
+            const steer = clamp(input.steer ?? 0, -1, 1);
+            const drift = clamp(state.drift + (input.drifting && Math.abs(steer) > 0.1 && speed > 2 ? seconds * 1.8 : -seconds * 1.2), 0, 1);
+            const heading = state.heading
+                + steer * steerRate * (0.28 + Math.min(1, Math.abs(speed) / maxSpeed))
+                    * (1 + drift * 0.55) * seconds * (speed < 0 ? -1 : 1);
+            state = {
+                x: state.x + Math.cos(heading) * speed * seconds,
+                z: state.z + Math.sin(heading) * speed * seconds,
+                heading,
+                speed,
+                drift
+            };
+            return snapshot();
+        },
+        constrain(constraint) {
+            state = {
+                ...state,
+                x: constraint.x ?? state.x,
+                z: constraint.z ?? state.z,
+                heading: constraint.heading ?? state.heading,
+                speed: state.speed * clamp(constraint.speedMultiplier ?? 1, 0, 1),
+                drift: state.drift * clamp(constraint.driftMultiplier ?? 1, 0, 1)
+            };
+            return snapshot();
+        },
+        reset(next = {}) {
+            state = {
+                x: next.x ?? 0,
+                z: next.z ?? 0,
+                heading: next.heading ?? 0,
+                speed: next.speed ?? 0,
+                drift: next.drift ?? 0
+            };
+            return snapshot();
+        },
+        snapshot
+    };
+}
 export function createGameKinematicBody(options = {}) {
     let position = vec3(options.position, [0, options.groundY ?? 0, 0]);
     let velocity = vec3(options.velocity, [0, 0, 0]);