@jgengine/core 0.6.0 → 0.7.0

package/dist/physics/structure.d.ts

@@ -0,0 +1,83 @@
+import type { PhysicsWorld } from "./physicsWorld.js";
+export interface StructureMaterial {
+    id: string;
+    /** Node integrity and edge strength default to this — brittle glass vs load-bearing concrete. */
+    strength: number;
+    /** Debris body mass when a node of this material collapses. Default 1. */
+    mass?: number;
+}
+export type StructureMaterialTable = Readonly<Record<string, StructureMaterial>>;
+export interface StructureNodeSpec {
+    id: string;
+    /** Body centre in world coordinates — also where its debris spawns. */
+    position: readonly [number, number, number];
+    halfExtents: readonly [number, number, number];
+    /** Overrides material mass for the collapsed debris body. */
+    mass?: number;
+    /** Hit points before the piece shatters. Default from `material.strength`, else 100. */
+    integrity?: number;
+    material?: string;
+    /** Foundation piece — reachability to any anchor is what keeps the rest standing. */
+    anchor?: boolean;
+}
+export interface StructureEdgeSpec {
+    a: string;
+    b: string;
+    /** Accumulated edge damage past this severs the connection. Default from `material.strength`, else 100. */
+    strength?: number;
+}
+export interface CollapseEvent {
+    /**
+     * Node ids that left the structure this operation — the shattered node plus every piece the loss
+     * disconnected from an anchor. This is the replicated collapse: broadcast the id list, not each
+     * fragment's physics (games re-derive the debris locally).
+     */
+    fell: readonly string[];
+    collapsed: boolean;
+}
+export interface DebrisConfig {
+    /** Outward kick magnitude applied to each debris body from `origin`. Default 3. */
+    impulse?: number;
+    /** Blast origin the kick radiates from. Defaults to each node's own position (straight drop). */
+    origin?: readonly [number, number, number];
+}
+/**
+ * A structural-integrity graph over a building — nodes are pieces (walls, beams, floors), edges are
+ * load-bearing connections, some nodes are anchored foundations. `damage`/`damageEdge` wear pieces and
+ * connections down; when a piece shatters or an edge severs, the graph recomputes which pieces still
+ * reach an anchor and hands back every newly-disconnected piece as one `CollapseEvent`. Feed that to
+ * `toDebris` to sink the fallen pieces into a `PhysicsWorld` as rigid bodies ("The Finals" smooth
+ * destruction, Rainbow Six walls). Coarse by design: it replicates the collapse event, not per fragment.
+ */
+export declare class StructureGraph {
+    private readonly nodes;
+    private readonly integrity;
+    private readonly adj;
+    private readonly edgeStrength;
+    private readonly edgeDamage;
+    private readonly fallenSpecs;
+    private readonly materials;
+    constructor(config: {
+        nodes: readonly StructureNodeSpec[];
+        edges: readonly StructureEdgeSpec[];
+        materials?: StructureMaterialTable;
+    });
+    private materialStrength;
+    has(id: string): boolean;
+    integrityOf(id: string): number;
+    nodeSpec(id: string): StructureNodeSpec | undefined;
+    neighbors(id: string): string[];
+    standing(): string[];
+    isSupported(id: string): boolean;
+    private supportedSet;
+    private removeNode;
+    private settle;
+    /** Wear a piece down; at ≤0 integrity it shatters and the loss cascades through unsupported pieces. */
+    damage(id: string, amount: number): CollapseEvent;
+    /** Wear a connection down; past its strength it severs and unsupported pieces cascade off. */
+    damageEdge(a: string, b: string, amount: number): CollapseEvent;
+    /** Cut a connection outright (a beam sheared by a blast), then cascade. */
+    severEdge(a: string, b: string): CollapseEvent;
+    /** Spawn one rigid debris body per fallen piece into `world`; returns the new body indices. */
+    toDebris(world: PhysicsWorld, event: CollapseEvent, config?: DebrisConfig): number[];
+}

package/dist/physics/traversal.d.ts

@@ -0,0 +1,75 @@
+import type { PhysicsWorld } from "./physicsWorld.js";
+export interface GrappleConfig {
+    /** Metres per second the rope shortens under `reel` / lengthens under `payOut`. Default 8. */
+    reelSpeed?: number;
+    /** Rope refuses to shorten past this — the traveller stops on top of the anchor, not inside it. Default 1.5. */
+    minLength?: number;
+    /** Firing range; `fire` beyond this misses. Default 40. */
+    maxLength?: number;
+    /** Elastic rope (spring) that yanks and bounces, vs a rigid `distance` cable that holds a hard length. Default false. */
+    elastic?: boolean;
+    /** Spring restoring rate when `elastic`. Default 40. */
+    stiffness?: number;
+    /** Spring damping when `elastic`. Default 6. */
+    damping?: number;
+}
+/**
+ * A fired-anchor rope on the joint API — grapple (reel toward a hit point), zipline (rigid cable to a
+ * far anchor you then slide/reel along), swing (rigid rope + gravity = a pendulum). `fire` attaches a
+ * `distance`/`spring` joint from the traveller body to a fixed world point; `reel` shrinks its rest
+ * length so the constraint drags the body in; `moveAnchor` re-points it (zipline glide, grapple-to-
+ * moving-target). The pick — a raycast to find the anchor — is the caller's; core owns the constraint.
+ */
+export declare class Grapple {
+    readonly body: number;
+    private readonly world;
+    private readonly reelSpeed;
+    private readonly minLength;
+    private readonly maxLength;
+    private readonly elastic;
+    private readonly stiffness;
+    private readonly damping;
+    private joint;
+    private length;
+    private ax;
+    private ay;
+    private az;
+    constructor(world: PhysicsWorld, body: number, config?: GrappleConfig);
+    get attached(): boolean;
+    get ropeLength(): number;
+    anchor(): readonly [number, number, number] | null;
+    distanceToAnchor(): number;
+    /** Attach to a world anchor point. Returns false (a miss) when the point is beyond `maxLength`. */
+    fire(x: number, y: number, z: number): boolean;
+    /** Shorten the rope by `reelSpeed * dt`, pulling the traveller toward the anchor. Clamps at `minLength`. */
+    reel(dt: number): void;
+    /** Pay out slack, lengthening the rope up to `maxLength`. */
+    payOut(dt: number): void;
+    /** Re-point the anchor (slide a zipline attachment along the cable, or track a moving target). */
+    moveAnchor(x: number, y: number, z: number): void;
+    release(): void;
+}
+export interface GlideConfig {
+    /** Fraction of world gravity the glider still feels — 1 is normal fall, 0 hangs. Default 0.25. */
+    gravityScale?: number;
+    /** Forward acceleration applied along the steer vector each `apply`. Default 6. */
+    thrust?: number;
+    /** Terminal descent clamp so a glide never plummets. Default 8. */
+    maxFallSpeed?: number;
+}
+/**
+ * A reduced-gravity, forward-thrust glide over a physics body — wingsuit / glider / paraglider
+ * (Enshrouded, Grounded). Call `apply(dt, steerX, steerZ)` each frame *before* `world.step`: it feeds
+ * back most of the gravity the sim is about to apply (leaving `gravityScale` of it), pushes the body
+ * along the steer vector by `thrust`, and clamps descent to `maxFallSpeed`. Stop calling it to fall
+ * normally again — no attach/detach state to leak.
+ */
+export declare class Glide {
+    readonly body: number;
+    private readonly world;
+    private readonly gravityScale;
+    private readonly thrust;
+    private readonly maxFallSpeed;
+    constructor(world: PhysicsWorld, body: number, config?: GlideConfig);
+    apply(dt: number, steerX?: number, steerZ?: number): void;
+}

package/dist/physics/traversal.js

@@ -0,0 +1,138 @@
+/**
+ * A fired-anchor rope on the joint API — grapple (reel toward a hit point), zipline (rigid cable to a
+ * far anchor you then slide/reel along), swing (rigid rope + gravity = a pendulum). `fire` attaches a
+ * `distance`/`spring` joint from the traveller body to a fixed world point; `reel` shrinks its rest
+ * length so the constraint drags the body in; `moveAnchor` re-points it (zipline glide, grapple-to-
+ * moving-target). The pick — a raycast to find the anchor — is the caller's; core owns the constraint.
+ */
+export class Grapple {
+    body;
+    world;
+    reelSpeed;
+    minLength;
+    maxLength;
+    elastic;
+    stiffness;
+    damping;
+    joint = -1;
+    length = 0;
+    ax = 0;
+    ay = 0;
+    az = 0;
+    constructor(world, body, config = {}) {
+        this.world = world;
+        this.body = body;
+        this.reelSpeed = config.reelSpeed ?? 8;
+        this.minLength = config.minLength ?? 1.5;
+        this.maxLength = config.maxLength ?? 40;
+        this.elastic = config.elastic ?? false;
+        this.stiffness = config.stiffness ?? 40;
+        this.damping = config.damping ?? 6;
+    }
+    get attached() {
+        return this.joint >= 0;
+    }
+    get ropeLength() {
+        return this.length;
+    }
+    anchor() {
+        return this.joint < 0 ? null : [this.ax, this.ay, this.az];
+    }
+    distanceToAnchor() {
+        const w = this.world;
+        const dx = this.ax - w.posX[this.body];
+        const dy = this.ay - w.posY[this.body];
+        const dz = this.az - w.posZ[this.body];
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+    /** Attach to a world anchor point. Returns false (a miss) when the point is beyond `maxLength`. */
+    fire(x, y, z) {
+        if (this.joint >= 0)
+            this.release();
+        const w = this.world;
+        const dx = x - w.posX[this.body];
+        const dy = y - w.posY[this.body];
+        const dz = z - w.posZ[this.body];
+        const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        if (dist > this.maxLength)
+            return false;
+        this.ax = x;
+        this.ay = y;
+        this.az = z;
+        this.length = dist;
+        const opts = {
+            bodyA: this.body,
+            anchorB: [x, y, z],
+            restLength: dist,
+            stiffness: this.stiffness,
+            damping: this.damping,
+        };
+        this.joint = this.elastic ? w.springJoint(opts) : w.distanceJoint(opts);
+        w.wake(this.body);
+        return true;
+    }
+    /** Shorten the rope by `reelSpeed * dt`, pulling the traveller toward the anchor. Clamps at `minLength`. */
+    reel(dt) {
+        if (this.joint < 0)
+            return;
+        this.length = Math.max(this.minLength, this.length - this.reelSpeed * dt);
+        this.world.setJointRest(this.joint, this.length);
+        this.world.wake(this.body);
+    }
+    /** Pay out slack, lengthening the rope up to `maxLength`. */
+    payOut(dt) {
+        if (this.joint < 0)
+            return;
+        this.length = Math.min(this.maxLength, this.length + this.reelSpeed * dt);
+        this.world.setJointRest(this.joint, this.length);
+        this.world.wake(this.body);
+    }
+    /** Re-point the anchor (slide a zipline attachment along the cable, or track a moving target). */
+    moveAnchor(x, y, z) {
+        if (this.joint < 0)
+            return;
+        this.ax = x;
+        this.ay = y;
+        this.az = z;
+        this.world.setJointAnchor(this.joint, x, y, z);
+        this.world.wake(this.body);
+    }
+    release() {
+        if (this.joint < 0)
+            return;
+        this.world.removeJoint(this.joint);
+        this.joint = -1;
+    }
+}
+/**
+ * A reduced-gravity, forward-thrust glide over a physics body — wingsuit / glider / paraglider
+ * (Enshrouded, Grounded). Call `apply(dt, steerX, steerZ)` each frame *before* `world.step`: it feeds
+ * back most of the gravity the sim is about to apply (leaving `gravityScale` of it), pushes the body
+ * along the steer vector by `thrust`, and clamps descent to `maxFallSpeed`. Stop calling it to fall
+ * normally again — no attach/detach state to leak.
+ */
+export class Glide {
+    body;
+    world;
+    gravityScale;
+    thrust;
+    maxFallSpeed;
+    constructor(world, body, config = {}) {
+        this.world = world;
+        this.body = body;
+        this.gravityScale = config.gravityScale ?? 0.25;
+        this.thrust = config.thrust ?? 6;
+        this.maxFallSpeed = config.maxFallSpeed ?? 8;
+    }
+    apply(dt, steerX = 0, steerZ = 0) {
+        const w = this.world;
+        const b = this.body;
+        const counter = -w.gravity * (1 - this.gravityScale);
+        w.velY[b] += counter * dt;
+        w.velX[b] += steerX * this.thrust * dt;
+        w.velZ[b] += steerZ * this.thrust * dt;
+        if (w.velY[b] < -this.maxFallSpeed)
+            w.velY[b] = -this.maxFallSpeed;
+        w.wake(b);
+    }
+}

package/dist/physics/vehicleBody.d.ts

@@ -0,0 +1,93 @@
+import type { PhysicsWorld } from "./physicsWorld.js";
+import type { AxisInput } from "../input/axisInput.js";
+export interface GripCurve {
+    points: readonly (readonly [number, number])[];
+}
+/**
+ * Piecewise-linear tire-grip curve: normalized lateral slip → available grip (0..1). Grip peaks near
+ * the breakaway slip then falls off as the tire slides — the shape that separates a planted corner
+ * from a drift. Points are read in ascending slip order; ends clamp.
+ */
+export declare function sampleGripCurve(curve: GripCurve, slip: number): number;
+export declare const DEFAULT_GRIP_CURVE: GripCurve;
+export interface WheelSpec {
+    offset: readonly [number, number, number];
+    radius?: number;
+    restLength?: number;
+    steered?: boolean;
+    powered?: boolean;
+    handbrakeLocks?: boolean;
+}
+export interface WheelState {
+    worldX: number;
+    worldY: number;
+    worldZ: number;
+    grounded: boolean;
+    compression: number;
+    steerAngle: number;
+}
+export interface VehicleBodyConfig {
+    position: readonly [number, number, number];
+    heading?: number;
+    chassisHalfExtents?: readonly [number, number, number];
+    mass?: number;
+    wheels?: readonly WheelSpec[];
+    engineAccel?: number;
+    brakeAccel?: number;
+    topSpeed?: number;
+    reverseSpeed?: number;
+    turnRate?: number;
+    turnSpeedRef?: number;
+    grip?: GripCurve;
+    gripStrength?: number;
+    handbrakeGrip?: number;
+    rollingResistance?: number;
+    suspensionRest?: number;
+    suspensionStiffness?: number;
+    suspensionDamping?: number;
+    groundHeight?: (x: number, z: number) => number;
+    surfaceFriction?: (x: number, z: number) => number;
+}
+/**
+ * Arcade vehicle over the {@link PhysicsWorld} rigid-body sim. The chassis is a single box body driven
+ * by an {@link AxisInput}: per-wheel suspension is a spring-damper held with G3's `springJoint` against
+ * the sampled ground, drive/brake push along the heading, and a tire-grip curve bleeds lateral velocity
+ * (cornering, and drift under handbrake). Because the chassis is a physics body it still collides — that
+ * contact feeds crash damage. Call `update(dt, input)` before the shared `world.step(dt)`.
+ */
+export declare class VehicleBody {
+    heading: number;
+    readonly chassis: number;
+    private readonly world;
+    private readonly wheels;
+    private readonly springs;
+    private readonly wheelStates;
+    private readonly engineAccel;
+    private readonly brakeAccel;
+    private readonly topSpeed;
+    private readonly reverseSpeed;
+    private readonly turnRate;
+    private readonly turnSpeedRef;
+    private readonly grip;
+    private readonly gripStrength;
+    private readonly handbrakeGrip;
+    private readonly rollingResistance;
+    private readonly suspensionRest;
+    private readonly groundHeight;
+    private readonly surfaceFriction;
+    private groundedCount;
+    constructor(world: PhysicsWorld, config: VehicleBodyConfig);
+    private wheelMount;
+    get position(): [number, number, number];
+    get forward(): [number, number];
+    /** Signed forward speed along the heading (negative = reversing). */
+    get speed(): number;
+    get grounded(): boolean;
+    wheelState(index: number): WheelState | null;
+    get wheelCount(): number;
+    resetTo(position: readonly [number, number, number], heading: number): void;
+    update(dt: number, input: AxisInput): void;
+    private updateSuspension;
+    remove(): void;
+}
+export declare function createVehicleBody(world: PhysicsWorld, config: VehicleBodyConfig): VehicleBody;

package/dist/physics/vehicleBody.js

@@ -0,0 +1,234 @@
+/**
+ * Piecewise-linear tire-grip curve: normalized lateral slip → available grip (0..1). Grip peaks near
+ * the breakaway slip then falls off as the tire slides — the shape that separates a planted corner
+ * from a drift. Points are read in ascending slip order; ends clamp.
+ */
+export function sampleGripCurve(curve, slip) {
+    const pts = curve.points;
+    if (pts.length === 0)
+        return 1;
+    const s = Math.abs(slip);
+    if (s <= pts[0][0])
+        return pts[0][1];
+    for (let i = 1; i < pts.length; i += 1) {
+        const [x1, y1] = pts[i];
+        if (s <= x1) {
+            const [x0, y0] = pts[i - 1];
+            const span = x1 - x0;
+            const t = span <= 0 ? 0 : (s - x0) / span;
+            return y0 + (y1 - y0) * t;
+        }
+    }
+    return pts[pts.length - 1][1];
+}
+export const DEFAULT_GRIP_CURVE = {
+    points: [
+        [0, 1],
+        [0.2, 1],
+        [0.45, 0.78],
+        [1, 0.55],
+    ],
+};
+function cornerWheels(half, rest, radius) {
+    const x = half[0];
+    const z = half[2];
+    const y = -half[1];
+    return [
+        { offset: [-x, y, z], steered: true, restLength: rest, radius },
+        { offset: [x, y, z], steered: true, restLength: rest, radius },
+        { offset: [-x, y, -z], powered: true, handbrakeLocks: true, restLength: rest, radius },
+        { offset: [x, y, -z], powered: true, handbrakeLocks: true, restLength: rest, radius },
+    ];
+}
+/**
+ * Arcade vehicle over the {@link PhysicsWorld} rigid-body sim. The chassis is a single box body driven
+ * by an {@link AxisInput}: per-wheel suspension is a spring-damper held with G3's `springJoint` against
+ * the sampled ground, drive/brake push along the heading, and a tire-grip curve bleeds lateral velocity
+ * (cornering, and drift under handbrake). Because the chassis is a physics body it still collides — that
+ * contact feeds crash damage. Call `update(dt, input)` before the shared `world.step(dt)`.
+ */
+export class VehicleBody {
+    heading;
+    chassis;
+    world;
+    wheels;
+    springs;
+    wheelStates;
+    engineAccel;
+    brakeAccel;
+    topSpeed;
+    reverseSpeed;
+    turnRate;
+    turnSpeedRef;
+    grip;
+    gripStrength;
+    handbrakeGrip;
+    rollingResistance;
+    suspensionRest;
+    groundHeight;
+    surfaceFriction;
+    groundedCount = 0;
+    constructor(world, config) {
+        this.world = world;
+        this.heading = config.heading ?? 0;
+        const half = config.chassisHalfExtents ?? [0.9, 0.35, 1.8];
+        this.suspensionRest = config.suspensionRest ?? 0.55;
+        const radius = 0.35;
+        this.wheels = config.wheels ?? cornerWheels(half, this.suspensionRest, radius);
+        this.engineAccel = config.engineAccel ?? 18;
+        this.brakeAccel = config.brakeAccel ?? 26;
+        this.topSpeed = config.topSpeed ?? 28;
+        this.reverseSpeed = config.reverseSpeed ?? 10;
+        this.turnRate = config.turnRate ?? 1.6;
+        this.turnSpeedRef = config.turnSpeedRef ?? 8;
+        this.grip = config.grip ?? DEFAULT_GRIP_CURVE;
+        this.gripStrength = config.gripStrength ?? 8;
+        this.handbrakeGrip = config.handbrakeGrip ?? 0.35;
+        this.rollingResistance = config.rollingResistance ?? 0.6;
+        const stiffness = config.suspensionStiffness ?? 60;
+        const damping = config.suspensionDamping ?? 8;
+        this.groundHeight = config.groundHeight ?? (() => 0);
+        this.surfaceFriction = config.surfaceFriction ?? (() => 1);
+        this.chassis = world.addBody({
+            position: config.position,
+            halfExtents: half,
+            mass: config.mass ?? 4,
+        });
+        this.springs = [];
+        this.wheelStates = [];
+        for (const wheel of this.wheels) {
+            const worldPos = this.wheelMount(wheel);
+            const rest = wheel.restLength ?? this.suspensionRest;
+            const id = world.springJoint({
+                bodyA: this.chassis,
+                anchorA: [wheel.offset[0], wheel.offset[1], wheel.offset[2]],
+                anchorB: [worldPos[0], worldPos[1] - rest, worldPos[2]],
+                restLength: rest,
+                stiffness,
+                damping,
+            });
+            this.springs.push(id);
+            this.wheelStates.push({
+                worldX: worldPos[0],
+                worldY: worldPos[1],
+                worldZ: worldPos[2],
+                grounded: false,
+                compression: 0,
+                steerAngle: 0,
+            });
+        }
+    }
+    wheelMount(wheel) {
+        const sin = Math.sin(this.heading);
+        const cos = Math.cos(this.heading);
+        const [ox, oy, oz] = wheel.offset;
+        return [
+            this.world.posX[this.chassis] + ox * cos + oz * sin,
+            this.world.posY[this.chassis] + oy,
+            this.world.posZ[this.chassis] - ox * sin + oz * cos,
+        ];
+    }
+    get position() {
+        return [this.world.posX[this.chassis], this.world.posY[this.chassis], this.world.posZ[this.chassis]];
+    }
+    get forward() {
+        return [Math.sin(this.heading), Math.cos(this.heading)];
+    }
+    /** Signed forward speed along the heading (negative = reversing). */
+    get speed() {
+        const [fx, fz] = this.forward;
+        return this.world.velX[this.chassis] * fx + this.world.velZ[this.chassis] * fz;
+    }
+    get grounded() {
+        return this.groundedCount > 0;
+    }
+    wheelState(index) {
+        return this.wheelStates[index] ?? null;
+    }
+    get wheelCount() {
+        return this.wheels.length;
+    }
+    resetTo(position, heading) {
+        const w = this.world;
+        const c = this.chassis;
+        w.posX[c] = position[0];
+        w.posY[c] = position[1];
+        w.posZ[c] = position[2];
+        w.velX[c] = 0;
+        w.velY[c] = 0;
+        w.velZ[c] = 0;
+        this.heading = heading;
+        w.wake(c);
+    }
+    update(dt, input) {
+        const w = this.world;
+        const c = this.chassis;
+        this.updateSuspension(input.steer);
+        const speed = this.speed;
+        const grounded = this.groundedCount > 0;
+        if (grounded) {
+            const steerScale = Math.min(1, Math.abs(speed) / this.turnSpeedRef);
+            const dir = speed >= 0 ? 1 : -1;
+            this.heading += input.steer * this.turnRate * steerScale * dir * dt;
+        }
+        const [fx, fz] = this.forward;
+        if (grounded) {
+            let accel = 0;
+            if (input.throttle > 0 && speed < this.topSpeed)
+                accel += input.throttle * this.engineAccel;
+            if (input.brake > 0) {
+                if (speed > 0.2)
+                    accel -= input.brake * this.brakeAccel;
+                else if (speed > -this.reverseSpeed)
+                    accel -= input.brake * this.engineAccel;
+            }
+            w.velX[c] += fx * accel * dt;
+            w.velZ[c] += fz * accel * dt;
+            const roll = Math.max(0, 1 - this.rollingResistance * dt * (input.throttle > 0 ? 0 : 1));
+            const forwardSpeed = w.velX[c] * fx + w.velZ[c] * fz;
+            const rolled = forwardSpeed * roll;
+            const lateralSpeed = -w.velX[c] * fz + w.velZ[c] * fx;
+            const surface = this.surfaceFriction(w.posX[c], w.posZ[c]);
+            const slip = Math.abs(lateralSpeed) / (Math.abs(forwardSpeed) + 1);
+            const handbrake = 1 - input.handbrake * (1 - this.handbrakeGrip);
+            const grip = sampleGripCurve(this.grip, slip) * surface * handbrake;
+            const keep = Math.max(0, 1 - grip * this.gripStrength * dt);
+            const newLateral = lateralSpeed * keep;
+            w.velX[c] = fx * rolled - fz * newLateral;
+            w.velZ[c] = fz * rolled + fx * newLateral;
+            w.wake(c);
+        }
+    }
+    updateSuspension(steer) {
+        this.groundedCount = 0;
+        const w = this.world;
+        for (let i = 0; i < this.wheels.length; i += 1) {
+            const wheel = this.wheels[i];
+            const state = this.wheelStates[i];
+            const mount = this.wheelMount(wheel);
+            const radius = wheel.radius ?? 0.35;
+            const rest = wheel.restLength ?? this.suspensionRest;
+            const groundY = this.groundHeight(mount[0], mount[2]);
+            const gap = mount[1] - (groundY + radius);
+            const maxTravel = rest + radius;
+            const grounded = gap <= maxTravel;
+            w.setJointAnchor(this.springs[i], mount[0], groundY + radius, mount[2]);
+            state.worldX = mount[0];
+            state.worldY = groundY + radius;
+            state.worldZ = mount[2];
+            state.grounded = grounded;
+            state.compression = Math.max(0, rest - gap);
+            state.steerAngle = wheel.steered === true ? steer : 0;
+            if (grounded)
+                this.groundedCount += 1;
+        }
+    }
+    remove() {
+        for (const id of this.springs)
+            this.world.removeJoint(id);
+        this.springs.length = 0;
+    }
+}
+export function createVehicleBody(world, config) {
+    return new VehicleBody(world, config);
+}