@jgengine/core 0.6.0 → 0.7.0

package/dist/nav/navGrid.js

@@ -0,0 +1,248 @@
+const SQRT2 = Math.SQRT2;
+function clampInt(value, min, max) {
+    return value < min ? min : value > max ? max : value;
+}
+export function createNavGrid(config) {
+    const { bounds, cellSize } = config;
+    if (!(cellSize > 0))
+        throw new Error("navGrid cellSize must be positive.");
+    const diagonal = config.diagonal ?? true;
+    const width = Math.max(bounds.maxX - bounds.minX, cellSize);
+    const depth = Math.max(bounds.maxZ - bounds.minZ, cellSize);
+    const cols = Math.max(1, Math.ceil(width / cellSize));
+    const rows = Math.max(1, Math.ceil(depth / cellSize));
+    const walkable = new Uint8Array(cols * rows).fill(1);
+    const index = (col, row) => row * cols + col;
+    const inBounds = (col, row) => col >= 0 && col < cols && row >= 0 && row < rows;
+    function cellAt(point) {
+        return {
+            col: clampInt(Math.floor((point[0] - bounds.minX) / cellSize), 0, cols - 1),
+            row: clampInt(Math.floor((point[1] - bounds.minZ) / cellSize), 0, rows - 1),
+        };
+    }
+    function center(col, row) {
+        return [bounds.minX + (col + 0.5) * cellSize, bounds.minZ + (row + 0.5) * cellSize];
+    }
+    function markAabb(aabb, value) {
+        const min = cellAt([aabb.minX, aabb.minZ]);
+        const max = cellAt([aabb.maxX, aabb.maxZ]);
+        for (let row = min.row; row <= max.row; row += 1) {
+            for (let col = min.col; col <= max.col; col += 1)
+                walkable[index(col, row)] = value;
+        }
+    }
+    const grid = {
+        cols,
+        rows,
+        cellSize,
+        bounds,
+        diagonal,
+        isWalkable: (col, row) => inBounds(col, row) && walkable[index(col, row)] === 1,
+        setWalkable(col, row, next) {
+            if (inBounds(col, row))
+                walkable[index(col, row)] = next ? 1 : 0;
+        },
+        blockAabb: (aabb) => markAabb(aabb, 0),
+        clearAabb: (aabb) => markAabb(aabb, 1),
+        reset: (next) => walkable.fill(next ? 1 : 0),
+        inBounds,
+        cellAt,
+        center,
+        nearestWalkable(point) {
+            const start = cellAt(point);
+            if (walkable[index(start.col, start.row)] === 1)
+                return start;
+            const maxRadius = Math.max(cols, rows);
+            for (let radius = 1; radius <= maxRadius; radius += 1) {
+                for (let row = start.row - radius; row <= start.row + radius; row += 1) {
+                    for (let col = start.col - radius; col <= start.col + radius; col += 1) {
+                        const onRing = Math.abs(col - start.col) === radius || Math.abs(row - start.row) === radius;
+                        if (!onRing || !inBounds(col, row))
+                            continue;
+                        if (walkable[index(col, row)] === 1)
+                            return { col, row };
+                    }
+                }
+            }
+            return null;
+        },
+        lineOfSight(from, to) {
+            const a = cellAt(from);
+            const b = cellAt(to);
+            let x = a.col;
+            let y = a.row;
+            const dx = Math.abs(b.col - a.col);
+            const dy = Math.abs(b.row - a.row);
+            const sx = a.col < b.col ? 1 : -1;
+            const sy = a.row < b.row ? 1 : -1;
+            let err = dx - dy;
+            for (;;) {
+                if (walkable[index(x, y)] === 0)
+                    return false;
+                if (x === b.col && y === b.row)
+                    return true;
+                const e2 = 2 * err;
+                if (e2 > -dy) {
+                    err -= dy;
+                    x += sx;
+                }
+                if (e2 < dx) {
+                    err += dx;
+                    y += sy;
+                }
+            }
+        },
+    };
+    return grid;
+}
+function heapPush(heap, node) {
+    heap.push(node);
+    let i = heap.length - 1;
+    while (i > 0) {
+        const parent = (i - 1) >> 1;
+        if (heap[parent].f <= heap[i].f)
+            break;
+        [heap[parent], heap[i]] = [heap[i], heap[parent]];
+        i = parent;
+    }
+}
+function heapPop(heap) {
+    const top = heap[0];
+    const last = heap.pop();
+    if (heap.length > 0 && last !== undefined) {
+        heap[0] = last;
+        let i = 0;
+        for (;;) {
+            const left = i * 2 + 1;
+            const right = left + 1;
+            let smallest = i;
+            if (left < heap.length && heap[left].f < heap[smallest].f)
+                smallest = left;
+            if (right < heap.length && heap[right].f < heap[smallest].f)
+                smallest = right;
+            if (smallest === i)
+                break;
+            [heap[smallest], heap[i]] = [heap[i], heap[smallest]];
+            i = smallest;
+        }
+    }
+    return top;
+}
+function withClearance(grid, clearance) {
+    if (!(clearance > 0))
+        return (col, row) => grid.isWalkable(col, row);
+    const pad = Math.max(0, Math.ceil(clearance / grid.cellSize / 2));
+    return (col, row) => {
+        for (let dy = -pad; dy <= pad; dy += 1) {
+            for (let dx = -pad; dx <= pad; dx += 1) {
+                if (!grid.isWalkable(col + dx, row + dy))
+                    return false;
+            }
+        }
+        return true;
+    };
+}
+/**
+ * A* over the walkable grid. Returns a polyline of world-space `[x, z]` waypoints
+ * from `from` to `to`, or `null` when no route exists. Blocked start/goal snap to
+ * the nearest walkable cell so a click on an obstacle still routes to its edge.
+ */
+export function findPath(grid, from, to, options = {}) {
+    const passable = withClearance(grid, options.clearance ?? 0);
+    const startCell = grid.cellAt(from);
+    const goalCell = grid.cellAt(to);
+    const start = passable(startCell.col, startCell.row) ? startCell : grid.nearestWalkable(from);
+    const goal = passable(goalCell.col, goalCell.row) ? goalCell : grid.nearestWalkable(to);
+    if (start === null || goal === null)
+        return null;
+    const cols = grid.cols;
+    const keyOf = (col, row) => row * cols + col;
+    const startKey = keyOf(start.col, start.row);
+    const goalKey = keyOf(goal.col, goal.row);
+    const gScore = new Map([[startKey, 0]]);
+    const cameFrom = new Map();
+    const closed = new Set();
+    const heap = [];
+    const heuristic = (col, row) => {
+        const dc = Math.abs(col - goal.col);
+        const dr = Math.abs(row - goal.row);
+        return grid.diagonal ? dc + dr + (SQRT2 - 2) * Math.min(dc, dr) : dc + dr;
+    };
+    heapPush(heap, { key: startKey, f: heuristic(start.col, start.row) });
+    const neighbours = grid.diagonal
+        ? [
+            [1, 0, 1],
+            [-1, 0, 1],
+            [0, 1, 1],
+            [0, -1, 1],
+            [1, 1, SQRT2],
+            [1, -1, SQRT2],
+            [-1, 1, SQRT2],
+            [-1, -1, SQRT2],
+        ]
+        : [
+            [1, 0, 1],
+            [-1, 0, 1],
+            [0, 1, 1],
+            [0, -1, 1],
+        ];
+    let found = false;
+    while (heap.length > 0) {
+        const current = heapPop(heap);
+        if (closed.has(current.key))
+            continue;
+        if (current.key === goalKey) {
+            found = true;
+            break;
+        }
+        closed.add(current.key);
+        const col = current.key % cols;
+        const row = (current.key - col) / cols;
+        const g = gScore.get(current.key);
+        for (const [dx, dy, step] of neighbours) {
+            const nc = col + dx;
+            const nr = row + dy;
+            if (!passable(nc, nr))
+                continue;
+            if (dx !== 0 && dy !== 0 && (!passable(col + dx, row) || !passable(col, row + dy)))
+                continue;
+            const nKey = keyOf(nc, nr);
+            if (closed.has(nKey))
+                continue;
+            const tentative = g + step;
+            if (tentative < (gScore.get(nKey) ?? Number.POSITIVE_INFINITY)) {
+                gScore.set(nKey, tentative);
+                cameFrom.set(nKey, current.key);
+                heapPush(heap, { key: nKey, f: tentative + heuristic(nc, nr) });
+            }
+        }
+    }
+    if (!found)
+        return null;
+    const cells = [];
+    let cursor = goalKey;
+    while (cursor !== undefined) {
+        const col = cursor % cols;
+        cells.unshift({ col, row: (cursor - col) / cols });
+        cursor = cameFrom.get(cursor);
+    }
+    const raw = cells.map((cell) => grid.center(cell.col, cell.row));
+    if (passable(goalCell.col, goalCell.row))
+        raw[raw.length - 1] = [to[0], to[1]];
+    return options.smooth === false ? raw : smoothPath(grid, raw);
+}
+/** Remove waypoints the mover can skip because it has clear line-of-sight past them. */
+export function smoothPath(grid, points) {
+    if (points.length <= 2)
+        return points.slice();
+    const result = [points[0]];
+    let anchor = 0;
+    for (let i = 2; i < points.length; i += 1) {
+        if (!grid.lineOfSight(points[anchor], points[i])) {
+            result.push(points[i - 1]);
+            anchor = i - 1;
+        }
+    }
+    result.push(points[points.length - 1]);
+    return result;
+}

package/dist/nav/pathFollow.d.ts

@@ -0,0 +1,29 @@
+import type { NavPoint } from "./navGrid.js";
+export type Waypoint = readonly [number, number, number];
+export interface PathFollowConfig {
+    waypoints: readonly Waypoint[];
+    /** World units per second. */
+    speed: number;
+    /** Wrap back to the first waypoint after the last (never `done`). Default false. */
+    loop?: boolean;
+}
+export interface PathFollowState {
+    position: Waypoint;
+    /** Index of the waypoint the mover is currently travelling toward. */
+    target: number;
+    /** Yaw (radians) of the current travel direction, matching engine `rotationY`. */
+    heading: number;
+    done: boolean;
+    /** Total world-distance covered so far — drives progress/leak logic in tower defense. */
+    distanceTravelled: number;
+}
+/** Lift an A* / navmesh `[x, z]` polyline onto a `y` plane for a path-follower. */
+export declare function pathFromNav(points: readonly NavPoint[], y?: number): Waypoint[];
+export declare function createPathFollow(config: PathFollowConfig): PathFollowState;
+/**
+ * Advance a path-follower by `speed * dt` along its authored polyline. Pure — returns
+ * the next state. Crosses multiple waypoints in one step, loops when configured, and
+ * reports `done` at the end of a non-looping path. No navmesh required (#52); feed it a
+ * navmesh route via `pathFromNav` for click-to-move (#51).
+ */
+export declare function advancePathFollow(config: PathFollowConfig, state: PathFollowState, dt: number): PathFollowState;

package/dist/nav/pathFollow.js

@@ -0,0 +1,67 @@
+/** Lift an A* / navmesh `[x, z]` polyline onto a `y` plane for a path-follower. */
+export function pathFromNav(points, y = 0) {
+    return points.map((point) => [point[0], y, point[1]]);
+}
+export function createPathFollow(config) {
+    const first = config.waypoints[0];
+    const start = first ?? [0, 0, 0];
+    return {
+        position: start,
+        target: config.waypoints.length > 1 ? 1 : 0,
+        heading: 0,
+        done: config.waypoints.length <= 1,
+        distanceTravelled: 0,
+    };
+}
+const EPSILON = 1e-9;
+/**
+ * Advance a path-follower by `speed * dt` along its authored polyline. Pure — returns
+ * the next state. Crosses multiple waypoints in one step, loops when configured, and
+ * reports `done` at the end of a non-looping path. No navmesh required (#52); feed it a
+ * navmesh route via `pathFromNav` for click-to-move (#51).
+ */
+export function advancePathFollow(config, state, dt) {
+    const { waypoints, speed } = config;
+    const loop = config.loop ?? false;
+    const count = waypoints.length;
+    if (count <= 1 || state.done || dt <= 0 || speed <= 0)
+        return state;
+    let position = state.position;
+    let target = state.target;
+    let heading = state.heading;
+    let distanceTravelled = state.distanceTravelled;
+    let budget = speed * dt;
+    let done = false;
+    let guard = count * 4 + 4;
+    while (budget > EPSILON && !done && guard > 0) {
+        guard -= 1;
+        const dest = waypoints[target];
+        const dx = dest[0] - position[0];
+        const dy = dest[1] - position[1];
+        const dz = dest[2] - position[2];
+        const dist = Math.hypot(dx, dy, dz);
+        if (dist > EPSILON)
+            heading = Math.atan2(dx, dz);
+        if (dist <= budget) {
+            position = dest;
+            budget -= dist;
+            distanceTravelled += dist;
+            if (target >= count - 1) {
+                if (loop)
+                    target = 0;
+                else
+                    done = true;
+            }
+            else {
+                target += 1;
+            }
+        }
+        else {
+            const t = budget / dist;
+            position = [position[0] + dx * t, position[1] + dy * t, position[2] + dz * t];
+            distanceTravelled += budget;
+            budget = 0;
+        }
+    }
+    return { position, target, heading, done, distanceTravelled };
+}

package/dist/physics/buoyancy.d.ts

@@ -0,0 +1,49 @@
+import type { PhysicsWorld } from "./physicsWorld.js";
+import type { WaterSurface } from "../world/water.js";
+import type { AxisInput } from "../input/axisInput.js";
+export interface BuoyantBodyConfig {
+    body: number;
+    water: WaterSurface;
+    heading?: number;
+    hullPoints?: readonly (readonly [number, number])[];
+    hullDepth?: number;
+    buoyancy?: number;
+    verticalDrag?: number;
+    linearDrag?: number;
+    engineAccel?: number;
+    reverseAccel?: number;
+    topSpeed?: number;
+    turnRate?: number;
+    turnSpeedRef?: number;
+}
+/**
+ * Floats a {@link PhysicsWorld} body on a CPU {@link WaterSurface}: each hull sample point pushes the
+ * body up by its submerged depth (Archimedes, coarse), with vertical and horizontal water drag so the
+ * hull settles at the waterline and rides the Gerstner waves. Passing an {@link AxisInput} drives it as
+ * a boat — throttle thrusts along the heading, steer yaws, a keel bleeds sideways slip. Call
+ * `update(dt, time, input?)` before the shared `world.step(dt)`.
+ */
+export declare class BuoyantBody {
+    heading: number;
+    private readonly world;
+    private readonly water;
+    private readonly body;
+    private readonly hull;
+    private readonly hullDepth;
+    private readonly buoyancy;
+    private readonly verticalDrag;
+    private readonly linearDrag;
+    private readonly engineAccel;
+    private readonly reverseAccel;
+    private readonly topSpeed;
+    private readonly turnRate;
+    private readonly turnSpeedRef;
+    private submergedFlag;
+    constructor(world: PhysicsWorld, config: BuoyantBodyConfig);
+    get position(): [number, number, number];
+    get forward(): [number, number];
+    get speed(): number;
+    get submerged(): boolean;
+    update(dt: number, time: number, input?: AxisInput): void;
+}
+export declare function createBuoyantBody(world: PhysicsWorld, config: BuoyantBodyConfig): BuoyantBody;

package/dist/physics/buoyancy.js

@@ -0,0 +1,112 @@
+const DEFAULT_HULL = [
+    [-0.8, 1.6],
+    [0.8, 1.6],
+    [-0.8, -1.6],
+    [0.8, -1.6],
+];
+/**
+ * Floats a {@link PhysicsWorld} body on a CPU {@link WaterSurface}: each hull sample point pushes the
+ * body up by its submerged depth (Archimedes, coarse), with vertical and horizontal water drag so the
+ * hull settles at the waterline and rides the Gerstner waves. Passing an {@link AxisInput} drives it as
+ * a boat — throttle thrusts along the heading, steer yaws, a keel bleeds sideways slip. Call
+ * `update(dt, time, input?)` before the shared `world.step(dt)`.
+ */
+export class BuoyantBody {
+    heading;
+    world;
+    water;
+    body;
+    hull;
+    hullDepth;
+    buoyancy;
+    verticalDrag;
+    linearDrag;
+    engineAccel;
+    reverseAccel;
+    topSpeed;
+    turnRate;
+    turnSpeedRef;
+    submergedFlag = false;
+    constructor(world, config) {
+        this.world = world;
+        this.heading = config.heading ?? 0;
+        this.water = config.water;
+        this.body = config.body;
+        this.hull = config.hullPoints ?? DEFAULT_HULL;
+        this.hullDepth = config.hullDepth ?? 0.5;
+        this.buoyancy = config.buoyancy ?? 26;
+        this.verticalDrag = config.verticalDrag ?? 3;
+        this.linearDrag = config.linearDrag ?? 1.2;
+        this.engineAccel = config.engineAccel ?? 10;
+        this.reverseAccel = config.reverseAccel ?? 5;
+        this.topSpeed = config.topSpeed ?? 14;
+        this.turnRate = config.turnRate ?? 1.2;
+        this.turnSpeedRef = config.turnSpeedRef ?? 4;
+    }
+    get position() {
+        return [this.world.posX[this.body], this.world.posY[this.body], this.world.posZ[this.body]];
+    }
+    get forward() {
+        return [Math.sin(this.heading), Math.cos(this.heading)];
+    }
+    get speed() {
+        const [fx, fz] = this.forward;
+        return this.world.velX[this.body] * fx + this.world.velZ[this.body] * fz;
+    }
+    get submerged() {
+        return this.submergedFlag;
+    }
+    update(dt, time, input) {
+        const w = this.world;
+        const b = this.body;
+        const sin = Math.sin(this.heading);
+        const cos = Math.cos(this.heading);
+        let submergedSum = 0;
+        let submergedCount = 0;
+        for (const [lx, lz] of this.hull) {
+            const px = w.posX[b] + lx * cos + lz * sin;
+            const pz = w.posZ[b] - lx * sin + lz * cos;
+            const surface = this.water.height(px, pz, time);
+            const bottom = w.posY[b] - this.hullDepth;
+            const depth = surface - bottom;
+            if (depth > 0) {
+                submergedSum += depth;
+                submergedCount += 1;
+            }
+        }
+        if (submergedCount > 0) {
+            const avgDepth = submergedSum / this.hull.length;
+            w.velY[b] += avgDepth * this.buoyancy * dt;
+            w.velY[b] -= w.velY[b] * Math.min(1, this.verticalDrag * dt);
+            const drag = Math.max(0, 1 - this.linearDrag * dt);
+            w.velX[b] *= drag;
+            w.velZ[b] *= drag;
+            this.submergedFlag = true;
+            w.wake(b);
+        }
+        else {
+            this.submergedFlag = false;
+        }
+        if (input !== undefined && this.submergedFlag) {
+            const speed = this.speed;
+            const steerScale = Math.min(1, Math.abs(speed) / this.turnSpeedRef);
+            this.heading += input.steer * this.turnRate * steerScale * dt;
+            const [fx, fz] = this.forward;
+            let accel = 0;
+            if (input.throttle > 0 && speed < this.topSpeed)
+                accel += input.throttle * this.engineAccel;
+            if (input.brake > 0 && speed > -this.topSpeed)
+                accel -= input.brake * this.reverseAccel;
+            w.velX[b] += fx * accel * dt;
+            w.velZ[b] += fz * accel * dt;
+            const lateral = -w.velX[b] * fz + w.velZ[b] * fx;
+            const forwardSpeed = w.velX[b] * fx + w.velZ[b] * fz;
+            const keptLateral = lateral * Math.max(0, 1 - 2 * dt);
+            w.velX[b] = fx * forwardSpeed - fz * keptLateral;
+            w.velZ[b] = fz * forwardSpeed + fx * keptLateral;
+        }
+    }
+}
+export function createBuoyantBody(world, config) {
+    return new BuoyantBody(world, config);
+}

package/dist/physics/carryable.d.ts

@@ -0,0 +1,46 @@
+import type { PhysicsWorld } from "./physicsWorld.js";
+export interface CarryableConfig {
+    /** Spring stiffness pulling the held body toward the follow point. Default 60. */
+    followStiffness?: number;
+    /** Spring damping on the follow constraint. Default 12. */
+    followDamping?: number;
+    /** Clamp on the follow impulse so a heavy item lags instead of teleporting. Default 40. */
+    maxForce?: number;
+    /** Mass one owner hauls at full speed; heavier → encumbered / needs more owners. Default 8. */
+    carryCapacity?: number;
+}
+/**
+ * Movement multiplier (1 = unhindered, →0 = crushed) for a body of `mass` carried by `owners`.
+ * Pure — the HUD/movement kit reads it to slow a laden hauler (Lethal Company) and to gate items
+ * that need 2+ people (R.E.P.O.).
+ */
+export declare function carrySpeedMultiplier(mass: number, carryCapacity: number, owners: number): number;
+/**
+ * A grabbed physics object following a moving hold point through a spring constraint (the pick —
+ * a raycast — is the caller's/shell's job; core owns the constraint). Supports shared multi-owner
+ * carry (the follow point is the average of owners' hold points), an encumbrance read, and
+ * drop/throw. Reuses `PhysicsWorld.springJoint` to a world anchor moved each frame.
+ */
+export declare class Carryable {
+    readonly body: number;
+    private readonly world;
+    private readonly stiffness;
+    private readonly damping;
+    private readonly maxForce;
+    private readonly capacity;
+    private readonly holds;
+    private joint;
+    constructor(world: PhysicsWorld, body: number, config?: CarryableConfig);
+    get held(): boolean;
+    get owners(): number;
+    private mass;
+    speedMultiplier(): number;
+    /** Add an owner grabbing at a hold point; the first owner creates the follow constraint. */
+    grab(ownerId: number, x: number, y: number, z: number): void;
+    setHoldPoint(ownerId: number, x: number, y: number, z: number): void;
+    release(ownerId: number): void;
+    /** Recompute the follow point (average of live hold points) and drive the constraint. */
+    update(): void;
+    drop(): void;
+    throw(vx: number, vy: number, vz: number): void;
+}

package/dist/physics/carryable.js

@@ -0,0 +1,110 @@
+/**
+ * Movement multiplier (1 = unhindered, →0 = crushed) for a body of `mass` carried by `owners`.
+ * Pure — the HUD/movement kit reads it to slow a laden hauler (Lethal Company) and to gate items
+ * that need 2+ people (R.E.P.O.).
+ */
+export function carrySpeedMultiplier(mass, carryCapacity, owners) {
+    if (owners <= 0)
+        return 0;
+    if (mass <= 0)
+        return 1;
+    const scale = (carryCapacity * owners) / mass;
+    return scale < 0 ? 0 : scale > 1 ? 1 : scale;
+}
+/**
+ * A grabbed physics object following a moving hold point through a spring constraint (the pick —
+ * a raycast — is the caller's/shell's job; core owns the constraint). Supports shared multi-owner
+ * carry (the follow point is the average of owners' hold points), an encumbrance read, and
+ * drop/throw. Reuses `PhysicsWorld.springJoint` to a world anchor moved each frame.
+ */
+export class Carryable {
+    body;
+    world;
+    stiffness;
+    damping;
+    maxForce;
+    capacity;
+    holds = new Map();
+    joint = -1;
+    constructor(world, body, config = {}) {
+        this.world = world;
+        this.body = body;
+        this.stiffness = config.followStiffness ?? 60;
+        this.damping = config.followDamping ?? 12;
+        this.maxForce = config.maxForce ?? 40;
+        this.capacity = config.carryCapacity ?? 8;
+    }
+    get held() {
+        return this.holds.size > 0;
+    }
+    get owners() {
+        return this.holds.size;
+    }
+    mass() {
+        const im = this.world.invMass[this.body];
+        return im > 0 ? 1 / im : Number.POSITIVE_INFINITY;
+    }
+    speedMultiplier() {
+        return carrySpeedMultiplier(this.mass(), this.capacity, this.holds.size);
+    }
+    /** Add an owner grabbing at a hold point; the first owner creates the follow constraint. */
+    grab(ownerId, x, y, z) {
+        this.holds.set(ownerId, [x, y, z]);
+        if (this.joint < 0) {
+            this.joint = this.world.springJoint({
+                bodyA: this.body,
+                restLength: 0,
+                stiffness: this.stiffness,
+                damping: this.damping,
+                maxImpulse: this.maxForce,
+                anchorB: [x, y, z],
+            });
+        }
+        this.world.wake(this.body);
+    }
+    setHoldPoint(ownerId, x, y, z) {
+        const h = this.holds.get(ownerId);
+        if (h === undefined)
+            return;
+        h[0] = x;
+        h[1] = y;
+        h[2] = z;
+    }
+    release(ownerId) {
+        this.holds.delete(ownerId);
+        if (this.holds.size === 0 && this.joint >= 0) {
+            this.world.removeJoint(this.joint);
+            this.joint = -1;
+        }
+    }
+    /** Recompute the follow point (average of live hold points) and drive the constraint. */
+    update() {
+        if (this.joint < 0 || this.holds.size === 0)
+            return;
+        let tx = 0;
+        let ty = 0;
+        let tz = 0;
+        for (const h of this.holds.values()) {
+            tx += h[0];
+            ty += h[1];
+            tz += h[2];
+        }
+        const inv = 1 / this.holds.size;
+        this.world.setJointAnchor(this.joint, tx * inv, ty * inv, tz * inv);
+        this.world.wake(this.body);
+    }
+    drop() {
+        this.holds.clear();
+        if (this.joint >= 0) {
+            this.world.removeJoint(this.joint);
+            this.joint = -1;
+        }
+    }
+    throw(vx, vy, vz) {
+        this.drop();
+        this.world.velX[this.body] = vx;
+        this.world.velY[this.body] = vy;
+        this.world.velZ[this.body] = vz;
+        this.world.wake(this.body);
+    }
+}