@jgengine/core 0.6.0 → 0.8.0

package/dist/physics/vehicleBody.d.ts

@@ -0,0 +1,99 @@
+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);
+    /**
+     * A wheel's local offset rotated by the current heading — the ground-side mount and the
+     * chassis-side spring anchor both derive from this, so the suspension axis stays vertical (not a
+     * mix of rotated and unrotated ends) as the chassis turns.
+     */
+    private rotateOffset;
+    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,233 @@
+/**
+ * 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: this.rotateOffset(wheel.offset),
+                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,
+            });
+        }
+    }
+    /**
+     * A wheel's local offset rotated by the current heading — the ground-side mount and the
+     * chassis-side spring anchor both derive from this, so the suspension axis stays vertical (not a
+     * mix of rotated and unrotated ends) as the chassis turns.
+     */
+    rotateOffset(offset) {
+        const sin = Math.sin(this.heading);
+        const cos = Math.cos(this.heading);
+        const [ox, oy, oz] = offset;
+        return [ox * cos + oz * sin, oy, -ox * sin + oz * cos];
+    }
+    wheelMount(wheel) {
+        const [dx, dy, dz] = this.rotateOffset(wheel.offset);
+        return [this.world.posX[this.chassis] + dx, this.world.posY[this.chassis] + dy, this.world.posZ[this.chassis] + dz];
+    }
+    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) {
+        this.world.teleport(this.chassis, position[0], position[1], position[2]);
+        this.heading = heading;
+    }
+    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;
+            const anchorA = this.rotateOffset(wheel.offset);
+            w.setJointAnchorA(this.springs[i], anchorA[0], anchorA[1], anchorA[2]);
+            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);
+}

package/dist/puzzle/cellGrid.d.ts

@@ -0,0 +1,26 @@
+export interface CellGrid<T> {
+    readonly width: number;
+    readonly height: number;
+    readonly cells: readonly (T | null)[];
+}
+export interface CellRun<T> {
+    readonly value: T;
+    readonly cells: readonly {
+        readonly x: number;
+        readonly y: number;
+    }[];
+    readonly direction: "row" | "column";
+}
+export declare function createCellGrid<T>(width: number, height: number): CellGrid<T>;
+export declare function inGridBounds<T>(grid: CellGrid<T>, x: number, y: number): boolean;
+export declare function cellAt<T>(grid: CellGrid<T>, x: number, y: number): T | null;
+export declare function withCell<T>(grid: CellGrid<T>, x: number, y: number, value: T | null): CellGrid<T>;
+export declare function withCells<T>(grid: CellGrid<T>, entries: readonly {
+    readonly x: number;
+    readonly y: number;
+    readonly value: T | null;
+}[]): CellGrid<T>;
+export declare function fullRows<T>(grid: CellGrid<T>): number[];
+export declare function clearRows<T>(grid: CellGrid<T>, rows: readonly number[]): CellGrid<T>;
+export declare function collapseColumns<T>(grid: CellGrid<T>): CellGrid<T>;
+export declare function findRuns<T>(grid: CellGrid<T>, minLength: number, matches?: (a: T, b: T) => boolean): CellRun<T>[];

package/dist/puzzle/cellGrid.js

@@ -0,0 +1,110 @@
+export function createCellGrid(width, height) {
+    return { width, height, cells: new Array(width * height).fill(null) };
+}
+export function inGridBounds(grid, x, y) {
+    return x >= 0 && x < grid.width && y >= 0 && y < grid.height;
+}
+export function cellAt(grid, x, y) {
+    if (!inGridBounds(grid, x, y))
+        return null;
+    return grid.cells[y * grid.width + x] ?? null;
+}
+export function withCell(grid, x, y, value) {
+    if (!inGridBounds(grid, x, y))
+        return grid;
+    const cells = grid.cells.slice();
+    cells[y * grid.width + x] = value;
+    return { width: grid.width, height: grid.height, cells };
+}
+export function withCells(grid, entries) {
+    const cells = grid.cells.slice();
+    for (const entry of entries) {
+        if (inGridBounds(grid, entry.x, entry.y))
+            cells[entry.y * grid.width + entry.x] = entry.value;
+    }
+    return { width: grid.width, height: grid.height, cells };
+}
+export function fullRows(grid) {
+    const rows = [];
+    for (let y = 0; y < grid.height; y += 1) {
+        let full = true;
+        for (let x = 0; x < grid.width; x += 1) {
+            if (cellAt(grid, x, y) === null) {
+                full = false;
+                break;
+            }
+        }
+        if (full)
+            rows.push(y);
+    }
+    return rows;
+}
+export function clearRows(grid, rows) {
+    const removed = new Set(rows);
+    const kept = [];
+    for (let y = 0; y < grid.height; y += 1) {
+        if (removed.has(y))
+            continue;
+        kept.push(grid.cells.slice(y * grid.width, y * grid.width + grid.width));
+    }
+    const clearedCount = grid.height - kept.length;
+    const cells = [];
+    for (let i = 0; i < clearedCount; i += 1)
+        cells.push(...new Array(grid.width).fill(null));
+    for (const row of kept)
+        cells.push(...row);
+    return { width: grid.width, height: grid.height, cells };
+}
+export function collapseColumns(grid) {
+    const cells = grid.cells.slice();
+    for (let x = 0; x < grid.width; x += 1) {
+        const values = [];
+        for (let y = 0; y < grid.height; y += 1) {
+            const value = cellAt(grid, x, y);
+            if (value !== null)
+                values.push(value);
+        }
+        const emptyCount = grid.height - values.length;
+        for (let y = 0; y < grid.height; y += 1) {
+            cells[y * grid.width + x] = y < emptyCount ? null : values[y - emptyCount];
+        }
+    }
+    return { width: grid.width, height: grid.height, cells };
+}
+function scanRuns(length, cellAtIndex, minLength, matches) {
+    const runs = [];
+    let start = 0;
+    for (let i = 1; i <= length; i += 1) {
+        const prev = cellAtIndex(i - 1);
+        const cur = i < length ? cellAtIndex(i) : null;
+        const continues = prev !== null && cur !== null && matches(prev, cur);
+        if (!continues) {
+            const runLength = i - start;
+            const value = cellAtIndex(start);
+            if (runLength >= minLength && value !== null)
+                runs.push({ value, start, end: i });
+            start = i;
+        }
+    }
+    return runs;
+}
+export function findRuns(grid, minLength, matches = (a, b) => a === b) {
+    const runs = [];
+    for (let y = 0; y < grid.height; y += 1) {
+        for (const run of scanRuns(grid.width, (x) => cellAt(grid, x, y), minLength, matches)) {
+            const cells = [];
+            for (let x = run.start; x < run.end; x += 1)
+                cells.push({ x, y });
+            runs.push({ value: run.value, cells, direction: "row" });
+        }
+    }
+    for (let x = 0; x < grid.width; x += 1) {
+        for (const run of scanRuns(grid.height, (y) => cellAt(grid, x, y), minLength, matches)) {
+            const cells = [];
+            for (let y = run.start; y < run.end; y += 1)
+                cells.push({ x, y });
+            runs.push({ value: run.value, cells, direction: "column" });
+        }
+    }
+    return runs;
+}

package/dist/puzzle/fallingPiece.d.ts

@@ -0,0 +1,24 @@
+import { type CellGrid } from "./cellGrid.js";
+export interface FallingPiece<TShape extends string = string> {
+    readonly shape: TShape;
+    readonly rotation: number;
+    readonly x: number;
+    readonly y: number;
+}
+export type ShapeTable<TShape extends string = string> = Record<TShape, readonly (readonly (readonly [number, number])[])[]>;
+export declare function pieceCells<TShape extends string>(table: ShapeTable<TShape>, piece: FallingPiece<TShape>): readonly (readonly [number, number])[];
+export declare function pieceCollides<T, TShape extends string>(grid: CellGrid<T>, table: ShapeTable<TShape>, piece: FallingPiece<TShape>): boolean;
+export declare function mergePiece<T, TShape extends string>(grid: CellGrid<T>, table: ShapeTable<TShape>, piece: FallingPiece<TShape>, value: T): CellGrid<T>;
+export declare function dropDistance<T, TShape extends string>(grid: CellGrid<T>, table: ShapeTable<TShape>, piece: FallingPiece<TShape>): number;
+export declare function gravityInterval(level: number, base?: number, perLevel?: number, min?: number): number;
+export declare function levelForLines(lines: number, linesPerLevel?: number): number;
+export declare function lineScore(cleared: number, level: number, table?: readonly number[]): number;
+export interface LockDelayState {
+    readonly delaySeconds: number;
+    readonly elapsed: number;
+}
+export declare function createLockDelay(delaySeconds: number): LockDelayState;
+export declare function stepLockDelay(state: LockDelayState, grounded: boolean, dt: number): {
+    state: LockDelayState;
+    locked: boolean;
+};

package/dist/puzzle/fallingPiece.js

@@ -0,0 +1,51 @@
+import { cellAt } from "./cellGrid.js";
+export function pieceCells(table, piece) {
+    const rotations = table[piece.shape];
+    const index = ((piece.rotation % rotations.length) + rotations.length) % rotations.length;
+    const state = rotations[index];
+    return state.map(([ox, oy]) => [piece.x + ox, piece.y + oy]);
+}
+export function pieceCollides(grid, table, piece) {
+    for (const [x, y] of pieceCells(table, piece)) {
+        if (x < 0 || x >= grid.width || y >= grid.height)
+            return true;
+        if (y >= 0 && cellAt(grid, x, y) !== null)
+            return true;
+    }
+    return false;
+}
+export function mergePiece(grid, table, piece, value) {
+    const cells = grid.cells.slice();
+    for (const [x, y] of pieceCells(table, piece)) {
+        if (x >= 0 && x < grid.width && y >= 0 && y < grid.height)
+            cells[y * grid.width + x] = value;
+    }
+    return { width: grid.width, height: grid.height, cells };
+}
+export function dropDistance(grid, table, piece) {
+    let distance = 0;
+    while (!pieceCollides(grid, table, { ...piece, y: piece.y + distance + 1 }))
+        distance += 1;
+    return distance;
+}
+export function gravityInterval(level, base = 0.8, perLevel = 0.07, min = 0.05) {
+    return Math.max(min, base - level * perLevel);
+}
+export function levelForLines(lines, linesPerLevel = 10) {
+    return Math.floor(lines / linesPerLevel);
+}
+const CLASSIC_LINE_SCORE = [0, 40, 100, 300, 1200];
+export function lineScore(cleared, level, table = CLASSIC_LINE_SCORE) {
+    return (table[cleared] ?? 0) * (level + 1);
+}
+export function createLockDelay(delaySeconds) {
+    return { delaySeconds, elapsed: 0 };
+}
+export function stepLockDelay(state, grounded, dt) {
+    if (!grounded)
+        return { state: { ...state, elapsed: 0 }, locked: false };
+    const elapsed = state.elapsed + dt;
+    if (elapsed >= state.delaySeconds)
+        return { state: { ...state, elapsed: 0 }, locked: true };
+    return { state: { ...state, elapsed }, locked: false };
+}

package/dist/random/nameGen.d.ts

@@ -0,0 +1,18 @@
+export interface SyllableBank {
+    onset?: readonly string[];
+    nucleus: readonly string[];
+    coda?: readonly string[];
+}
+export interface NameGeneratorOptions {
+    rng: () => number;
+    syllables: SyllableBank;
+    minSyllables?: number;
+    maxSyllables?: number;
+    capitalize?: boolean;
+}
+export interface NameGenerator {
+    name(): string;
+}
+export declare function pickFrom(rng: () => number, bank: readonly string[]): string;
+export declare function createNameGenerator(options: NameGeneratorOptions): NameGenerator;
+export declare function fillTemplate(template: string, vars: Record<string, () => string> | Record<string, string>): string;

package/dist/random/nameGen.js

@@ -0,0 +1,35 @@
+export function pickFrom(rng, bank) {
+    if (bank.length === 0)
+        throw new Error("pickFrom: bank must not be empty");
+    return bank[Math.floor(rng() * bank.length)];
+}
+export function createNameGenerator(options) {
+    const { rng, syllables } = options;
+    const minSyllables = Math.max(1, options.minSyllables ?? 2);
+    const maxSyllables = Math.max(minSyllables, options.maxSyllables ?? minSyllables);
+    const capitalize = options.capitalize ?? true;
+    function syllable() {
+        const onset = syllables.onset === undefined || syllables.onset.length === 0 ? "" : pickFrom(rng, syllables.onset);
+        const nucleus = pickFrom(rng, syllables.nucleus);
+        const coda = syllables.coda === undefined || syllables.coda.length === 0 ? "" : pickFrom(rng, syllables.coda);
+        return `${onset}${nucleus}${coda}`;
+    }
+    return {
+        name() {
+            const span = maxSyllables - minSyllables;
+            const count = minSyllables + (span === 0 ? 0 : Math.floor(rng() * (span + 1)));
+            let result = "";
+            for (let i = 0; i < count; i++)
+                result += syllable();
+            return capitalize && result.length > 0 ? result.charAt(0).toUpperCase() + result.slice(1) : result;
+        },
+    };
+}
+export function fillTemplate(template, vars) {
+    return template.replace(/\{(\w+)\}/g, (match, key) => {
+        if (!(key in vars))
+            return match;
+        const value = vars[key];
+        return typeof value === "function" ? value() : value;
+    });
+}

package/dist/random/rng.d.ts

@@ -0,0 +1,2 @@
+export declare function seededRng(seed: string | number): () => number;
+export declare function seededStreams(seed: string | number): (stream: string) => () => number;

package/dist/random/rng.js

@@ -0,0 +1,23 @@
+function hashSeed(seed) {
+    const text = typeof seed === "number" ? seed.toString() : seed;
+    let h = 2166136261 >>> 0;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
+export function seededRng(seed) {
+    let a = hashSeed(seed) >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+export function seededStreams(seed) {
+    const base = typeof seed === "number" ? seed.toString() : seed;
+    return (stream) => seededRng(`${base}:${stream}`);
+}

package/dist/runtime/adapter.d.ts

@@ -5,6 +5,20 @@ export type MultiplayerAdapterConfig = {
 } | {
     kind: "ws";
     topology?: MultiplayerTopology;
+    url?: string;
+} | {
+    kind: "socketio";
+    topology?: MultiplayerTopology;
+    url?: string;
+} | {
+    kind: "p2p";
+    topology?: MultiplayerTopology;
+    room?: string;
+} | {
+    kind: "lan";
+    topology?: MultiplayerTopology;
+    port?: number;
+    path?: string;
 } | {
     kind: "offline";
 };
@@ -13,8 +27,29 @@ export declare function convex(config?: {
 }): MultiplayerAdapterConfig;
 export declare function ws(config?: {
     topology?: MultiplayerTopology;
+    url?: string;
+}): MultiplayerAdapterConfig;
+export declare function fly(config: {
+    app: string;
+    topology?: MultiplayerTopology;
+    path?: string;
+}): MultiplayerAdapterConfig;
+export declare function socketIo(config?: {
+    topology?: MultiplayerTopology;
+    url?: string;
+}): MultiplayerAdapterConfig;
+export declare function p2p(config?: {
+    topology?: MultiplayerTopology;
+    room?: string;
+}): MultiplayerAdapterConfig;
+export declare function lan(config?: {
+    topology?: MultiplayerTopology;
+    port?: number;
+    path?: string;
 }): MultiplayerAdapterConfig;
 export declare function offline(): MultiplayerAdapterConfig;
+export declare function adapterOf(multiplayer: unknown): MultiplayerAdapterConfig | null;
+export declare function multiplayerAdapterKind(multiplayer: unknown): string | null;
 export type ServersPoolConfig = {
     maxServers: number;
     slotsPerServer: number;