@series-inc/rundot-syncplay 5.23.0-beta.7

package/dist/physics-cert.js

@@ -0,0 +1,389 @@
+import { defaultChecksum } from './canonical.js';
+import { fixedCircle, fixedVec2, circleIntersects } from './collision.js';
+const rapier2dCompatPackage = '@dimforge/rapier2d-compat';
+const physicsCertResults = {
+    true: 'pass',
+    false: 'fail',
+};
+export function runPhysicsCert(options) {
+    validateOptions(options);
+    const uninterrupted = runPhysicsSimulation(options, false);
+    const restored = runPhysicsSimulation(options, true);
+    const snapshotBytes = [...restored.snapshotBytes].sort((left, right) => left - right);
+    const stepTimings = [...restored.stepTimings].sort((left, right) => left - right);
+    const snapshotTimings = [...restored.snapshotTimings].sort((left, right) => left - right);
+    const restoreTimings = [...restored.restoreTimings].sort((left, right) => left - right);
+    const collisionEventsStable = defaultChecksum(uninterrupted.collisionEvents) === defaultChecksum(restored.collisionEvents);
+    const finalRestoreStable = uninterrupted.finalChecksum === restored.finalChecksum;
+    const snapshotHashStable = restored.snapshotChecksums.every((snapshot) => snapshot.first === snapshot.second);
+    const pass = finalRestoreStable &&
+        collisionEventsStable &&
+        restored.queryOrderStable &&
+        snapshotHashStable;
+    return {
+        engine: options.engine,
+        engineVersion: 'builtin-fixed@1',
+        adapterVersion: 'physics-cert@1',
+        shape: options.shape,
+        players: options.players,
+        bodies: createInitialBodies(options).length,
+        frames: options.frames,
+        snapshotEvery: options.snapshotEvery,
+        seed: options.seed,
+        uninterruptedChecksum: uninterrupted.finalChecksum,
+        restoredChecksum: restored.finalChecksum,
+        collisionEvents: restored.collisionEvents.length,
+        collisionEventsStable,
+        queryOrderStable: restored.queryOrderStable,
+        snapshotHashStable,
+        finalRestoreStable,
+        stepMsP95: percentile(stepTimings, 0.95),
+        stepMsMax: maxTiming(stepTimings),
+        snapshotMsP95: percentile(snapshotTimings, 0.95),
+        restoreMsP95: percentile(restoreTimings, 0.95),
+        snapshotBytesP95: percentileNumber(snapshotBytes, 0.95),
+        heapUsedBytes: getHeapUsedBytes(),
+        knownIssueRapier910: 'not-applicable',
+        result: physicsCertResult(pass),
+    };
+}
+export async function runRapierPhysicsCert(options) {
+    validateRapierOptions(options);
+    const rapier = await loadRapier2dCompat();
+    const uninterrupted = runRapierSimulation(rapier, options, false);
+    const restored = runRapierSimulation(rapier, options, true);
+    const snapshotBytes = [...restored.snapshotBytes].sort((left, right) => left - right);
+    const stepTimings = [...restored.stepTimings].sort((left, right) => left - right);
+    const snapshotTimings = [...restored.snapshotTimings].sort((left, right) => left - right);
+    const restoreTimings = [...restored.restoreTimings].sort((left, right) => left - right);
+    const collisionEventsStable = defaultChecksum(uninterrupted.collisionEvents) === defaultChecksum(restored.collisionEvents);
+    const finalRestoreStable = uninterrupted.finalChecksum === restored.finalChecksum;
+    const snapshotHashStable = restored.snapshotChecksums.every((snapshot) => snapshot.first === snapshot.second);
+    const pass = finalRestoreStable &&
+        collisionEventsStable &&
+        restored.queryOrderStable &&
+        snapshotHashStable;
+    return {
+        engine: options.engine,
+        engineVersion: `rapier2d-compat@${rapier.version()}`,
+        adapterVersion: 'physics-cert-rapier@1',
+        shape: options.shape,
+        players: options.players,
+        bodies: countRapierDynamicBodies(options),
+        frames: options.frames,
+        snapshotEvery: options.snapshotEvery,
+        seed: options.seed,
+        uninterruptedChecksum: uninterrupted.finalChecksum,
+        restoredChecksum: restored.finalChecksum,
+        collisionEvents: restored.collisionEvents.length,
+        collisionEventsStable,
+        queryOrderStable: restored.queryOrderStable,
+        snapshotHashStable,
+        finalRestoreStable,
+        stepMsP95: percentile(stepTimings, 0.95),
+        stepMsMax: maxTiming(stepTimings),
+        snapshotMsP95: percentile(snapshotTimings, 0.95),
+        restoreMsP95: percentile(restoreTimings, 0.95),
+        snapshotBytesP95: percentileNumber(snapshotBytes, 0.95),
+        heapUsedBytes: getHeapUsedBytes(),
+        knownIssueRapier910: finalRestoreStable && snapshotHashStable ? 'not-reproduced' : 'reproduced',
+        packageName: rapier2dCompatPackage,
+        packageImportPath: rapier2dCompatPackage,
+        result: physicsCertResult(pass),
+    };
+}
+async function loadRapier2dCompat() {
+    const mod = await import(rapier2dCompatPackage);
+    const warn = console.warn;
+    console.warn = () => { };
+    try {
+        await mod.init({});
+    }
+    finally {
+        console.warn = warn;
+    }
+    return mod;
+}
+function runRapierSimulation(rapier, options, withRestore) {
+    let world = createRapierWorld(rapier, options);
+    const stepTimings = [];
+    const snapshotTimings = [];
+    const restoreTimings = [];
+    const snapshotBytes = [];
+    const snapshotChecksums = [];
+    const collisionEvents = [];
+    let queryOrderStable = true;
+    for (let frame = 0; frame < options.frames; frame += 1) {
+        const stepStartedAt = performance.now();
+        world.step();
+        stepTimings.push(performance.now() - stepStartedAt);
+        const firstContacts = collectRapierContactPairs(world);
+        const secondContacts = collectRapierContactPairs(world);
+        queryOrderStable = queryOrderStable && defaultChecksum(firstContacts.raw) === defaultChecksum(secondContacts.raw);
+        for (const contact of firstContacts.canonical) {
+            collisionEvents.push(`${frame + 1}:${contact}`);
+        }
+        if (withRestore && frame % options.snapshotEvery === 0) {
+            const snapshotStartedAt = performance.now();
+            const snapshot = world.takeSnapshot();
+            snapshotTimings.push(performance.now() - snapshotStartedAt);
+            snapshotBytes.push(snapshot.byteLength);
+            const restoreStartedAt = performance.now();
+            const restored = rapier.World.restoreSnapshot(snapshot);
+            restoreTimings.push(performance.now() - restoreStartedAt);
+            snapshotChecksums.push({
+                first: defaultChecksum(Array.from(snapshot)),
+                second: defaultChecksum(Array.from(restored.takeSnapshot())),
+            });
+            world.free?.();
+            world = restored;
+        }
+    }
+    const finalSnapshot = world.takeSnapshot();
+    const finalChecksum = defaultChecksum({
+        snapshot: Array.from(finalSnapshot),
+        sample: sampleRapierWorld(world),
+    });
+    world.free?.();
+    return {
+        finalChecksum,
+        collisionEvents,
+        queryOrderStable,
+        stepTimings,
+        snapshotTimings,
+        restoreTimings,
+        snapshotBytes,
+        snapshotChecksums,
+    };
+}
+function createRapierWorld(rapier, options) {
+    const world = new rapier.World({ x: 0, y: 0 });
+    world.integrationParameters.dt = 1 / 30;
+    const bounds = options.shape === 'fixed-arena' ? 32 : 96;
+    const wall = 1;
+    const walls = [
+        { x: 0, y: -bounds - wall, halfWidth: bounds + wall, halfHeight: wall },
+        { x: 0, y: bounds + wall, halfWidth: bounds + wall, halfHeight: wall },
+        { x: -bounds - wall, y: 0, halfWidth: wall, halfHeight: bounds + wall },
+        { x: bounds + wall, y: 0, halfWidth: wall, halfHeight: bounds + wall },
+    ];
+    for (const wallConfig of walls) {
+        const body = world.createRigidBody(rapier.RigidBodyDesc.fixed().setTranslation(wallConfig.x, wallConfig.y));
+        world.createCollider(rapier.ColliderDesc.cuboid(wallConfig.halfWidth, wallConfig.halfHeight).setRestitution(1).setFriction(0), body);
+    }
+    const bodiesPerSlot = options.shape === 'fixed-arena' ? 2 : 4;
+    for (let slot = 0; slot < options.players; slot += 1) {
+        for (let index = 0; index < bodiesPerSlot; index += 1) {
+            const bodyIndex = slot * bodiesPerSlot + index;
+            const x = -bounds + 4 + ((bodyIndex * 7 + options.seed) % Math.max(8, bounds * 2 - 8));
+            const y = -bounds + 4 + ((bodyIndex * 11 + options.seed * 3) % Math.max(8, bounds * 2 - 8));
+            const vx = (((slot + index + options.seed) % 5) - 2 || 1) * 2;
+            const vy = (((slot * 3 + index + options.seed) % 5) - 2 || -1) * 2;
+            const body = world.createRigidBody(rapier.RigidBodyDesc.dynamic()
+                .setTranslation(x, y)
+                .setLinvel(vx, vy)
+                .setLinearDamping(0));
+            world.createCollider(rapier.ColliderDesc.ball(1 + ((slot + index + options.seed) % 3) * 0.25).setRestitution(1).setFriction(0), body);
+        }
+    }
+    return world;
+}
+function collectRapierContactPairs(world) {
+    const colliderHandles = [];
+    const raw = [];
+    const canonical = new Set();
+    world.colliders.forEach((collider) => {
+        colliderHandles.push(String(collider.handle));
+    });
+    for (const colliderHandle of colliderHandles) {
+        world.narrowPhase.contactPairsWith(Number(colliderHandle), (otherCollider) => {
+            const pair = [colliderHandle, String(otherCollider)].sort((left, right) => left.localeCompare(right));
+            const canonicalPair = `${pair[0]}:${pair[1]}`;
+            raw.push(canonicalPair);
+            canonical.add(canonicalPair);
+        });
+    }
+    return {
+        raw,
+        canonical: [...canonical].sort((left, right) => left.localeCompare(right)),
+    };
+}
+function sampleRapierWorld(world) {
+    const bodies = [];
+    world.bodies.forEach((body) => {
+        const translation = body.translation();
+        const linvel = body.linvel();
+        bodies.push({
+            handle: String(body.handle),
+            x: quantizeRapierNumber(translation.x),
+            y: quantizeRapierNumber(translation.y),
+            vx: quantizeRapierNumber(linvel.x),
+            vy: quantizeRapierNumber(linvel.y),
+        });
+    });
+    return bodies.sort((left, right) => left.handle.localeCompare(right.handle));
+}
+function quantizeRapierNumber(value) {
+    const rounded = Math.round(value * 1_000_000);
+    return rounded === 0 ? 0 : rounded;
+}
+function countRapierDynamicBodies(options) {
+    return options.players * (options.shape === 'fixed-arena' ? 2 : 4);
+}
+function runPhysicsSimulation(options, withRestore) {
+    let state = {
+        frame: 0,
+        bodies: createInitialBodies(options),
+        collisionEvents: [],
+    };
+    const stepTimings = [];
+    const snapshotTimings = [];
+    const restoreTimings = [];
+    const snapshotBytes = [];
+    const snapshotChecksums = [];
+    let queryOrderStable = true;
+    for (let frame = 0; frame < options.frames; frame += 1) {
+        const stepStartedAt = performance.now();
+        state = stepPhysics(state, options);
+        stepTimings.push(performance.now() - stepStartedAt);
+        if (withRestore && frame % options.snapshotEvery === 0) {
+            const snapshotStartedAt = performance.now();
+            const snapshot = JSON.stringify(state);
+            snapshotTimings.push(performance.now() - snapshotStartedAt);
+            snapshotBytes.push(Buffer.byteLength(snapshot));
+            snapshotChecksums.push({ first: defaultChecksum(snapshot), second: defaultChecksum(JSON.stringify(state)) });
+            const restoreStartedAt = performance.now();
+            state = JSON.parse(snapshot);
+            restoreTimings.push(performance.now() - restoreStartedAt);
+        }
+        const queried = queryBodiesNearOrigin(state);
+        const sorted = [...queried].sort((left, right) => left.localeCompare(right));
+        queryOrderStable = queryOrderStable && queried.every((id, index) => id === sorted[index]);
+    }
+    return {
+        finalChecksum: defaultChecksum(state),
+        collisionEvents: state.collisionEvents,
+        queryOrderStable,
+        stepTimings,
+        snapshotTimings,
+        restoreTimings,
+        snapshotBytes,
+        snapshotChecksums,
+    };
+}
+function createInitialBodies(options) {
+    const bodiesPerSlot = options.shape === 'fixed-arena' ? 2 : 4;
+    const bodies = [];
+    for (let slot = 0; slot < options.players; slot += 1) {
+        for (let index = 0; index < bodiesPerSlot; index += 1) {
+            bodies.push({
+                id: `slot-${slot}-body-${index}`,
+                slot,
+                radius: 6 + ((slot + index + options.seed) % 5),
+                x: -400 + slot * 9 + index * 11,
+                y: -120 + ((slot * 17 + index * 23 + options.seed) % 240),
+                vx: ((slot + index + options.seed) % 7) - 3 || 1,
+                vy: ((slot * 3 + index + options.seed) % 5) - 2 || -1,
+            });
+        }
+    }
+    return bodies;
+}
+function stepPhysics(state, options) {
+    const moved = state.bodies.map((body) => moveBody(body, options));
+    const collisionEvents = [...state.collisionEvents];
+    const circles = moved.map((body) => ({ body, circle: fixedCircle(fixedVec2(body.x, body.y), body.radius) }));
+    for (let leftIndex = 0; leftIndex < circles.length; leftIndex += 1) {
+        for (let rightIndex = leftIndex + 1; rightIndex < circles.length; rightIndex += 1) {
+            const left = circles[leftIndex];
+            const right = circles[rightIndex];
+            if (circleIntersects(left.circle, right.circle)) {
+                const ids = [left.body.id, right.body.id].sort();
+                collisionEvents.push(`${state.frame + 1}:${ids[0]}:${ids[1]}`);
+            }
+        }
+    }
+    return {
+        frame: state.frame + 1,
+        bodies: moved.sort((left, right) => left.id.localeCompare(right.id)),
+        collisionEvents,
+    };
+}
+function moveBody(body, options) {
+    const min = options.shape === 'fixed-arena' ? -512 : -1024;
+    const max = options.shape === 'fixed-arena' ? 512 : 1024;
+    let nextX = body.x + body.vx;
+    let nextY = body.y + body.vy;
+    let nextVx = body.vx;
+    let nextVy = body.vy;
+    if (nextX - body.radius < min || nextX + body.radius > max) {
+        nextVx = -nextVx;
+        nextX = body.x + nextVx;
+    }
+    if (nextY - body.radius < min || nextY + body.radius > max) {
+        nextVy = -nextVy;
+        nextY = body.y + nextVy;
+    }
+    return {
+        ...body,
+        x: nextX,
+        y: nextY,
+        vx: nextVx,
+        vy: nextVy,
+    };
+}
+function queryBodiesNearOrigin(state) {
+    const origin = fixedCircle(fixedVec2(0, 0), 256);
+    return state.bodies
+        .filter((body) => circleIntersects(origin, bodyToCircle(body)))
+        .map((body) => body.id)
+        .sort((left, right) => left.localeCompare(right));
+}
+function bodyToCircle(body) {
+    return fixedCircle(fixedVec2(body.x, body.y), body.radius);
+}
+function percentile(timings, percent) {
+    return percentileNumber(timings, percent).toFixed(4);
+}
+function percentileNumber(values, percent) {
+    const index = Math.min(values.length - 1, Math.ceil(values.length * percent) - 1);
+    return values[index];
+}
+function maxTiming(timings) {
+    return timings.at(-1).toFixed(4);
+}
+function getHeapUsedBytes() {
+    return typeof process === 'undefined' ? 0 : process.memoryUsage().heapUsed;
+}
+function physicsCertResult(pass) {
+    return physicsCertResults[String(pass)];
+}
+function validateOptions(options) {
+    if (options.engine !== 'builtin-fixed') {
+        throw new Error('physics certification currently supports engine=builtin-fixed');
+    }
+    validateCommonOptions(options);
+}
+function validateRapierOptions(options) {
+    if (options.engine !== 'rapier2d-compat') {
+        throw new Error('Rapier physics certification requires engine=rapier2d-compat');
+    }
+    validateCommonOptions(options);
+}
+function validateCommonOptions(options) {
+    if (options.shape !== 'fixed-arena' && options.shape !== 'slot-load') {
+        throw new Error('physics certification shape must be fixed-arena or slot-load');
+    }
+    if (!Number.isInteger(options.players) || options.players < 1 || options.players > 128) {
+        throw new Error('physics certification players must be between 1 and 128');
+    }
+    if (!Number.isInteger(options.frames) || options.frames < 1) {
+        throw new Error('physics certification frames must be at least 1');
+    }
+    if (!Number.isInteger(options.seed)) {
+        throw new Error('physics certification seed must be an integer');
+    }
+    if (!Number.isInteger(options.snapshotEvery) || options.snapshotEvery < 1) {
+        throw new Error('snapshotEvery must be a positive integer');
+    }
+}

package/dist/physics2d.d.ts

@@ -0,0 +1,142 @@
+import { type DeterministicPhysicsMaterial } from './deterministic-primitives.js';
+export type DeterministicBodyKind = 'static' | 'dynamic' | 'kinematic';
+export type DeterministicContactEventType = 'enter' | 'stay' | 'exit';
+export type DeterministicPhysicsShape2D = {
+    readonly type: 'aabb';
+} | {
+    readonly type: 'circle';
+    readonly radius: number;
+} | {
+    readonly type: 'capsule';
+    readonly radius: number;
+    readonly halfHeight: number;
+} | {
+    readonly type: 'convex';
+    readonly vertices: readonly {
+        readonly x: number;
+        readonly y: number;
+    }[];
+};
+export interface DeterministicPhysicsBody2D {
+    readonly id: string;
+    readonly kind: DeterministicBodyKind;
+    readonly x: number;
+    readonly y: number;
+    readonly z?: number;
+    readonly vx: number;
+    readonly vy: number;
+    readonly halfWidth: number;
+    readonly halfHeight: number;
+    readonly shape?: DeterministicPhysicsShape2D;
+    readonly halfDepth?: number;
+    readonly layer: number;
+    readonly mask: number;
+    readonly sensor?: boolean;
+    readonly trigger?: boolean;
+    readonly mass?: number;
+    readonly damping?: number;
+    readonly material?: DeterministicPhysicsMaterial;
+}
+export interface DeterministicPhysicsConstraint2D {
+    readonly id: string;
+    readonly type: 'distance' | 'fixed' | 'spring' | 'motor';
+    readonly a: string;
+    readonly b?: string;
+    readonly restLength?: number;
+    readonly offsetX?: number;
+    readonly offsetY?: number;
+    readonly stiffness?: number;
+    readonly motorVx?: number;
+    readonly motorVy?: number;
+}
+export interface DeterministicPhysicsWorld2D {
+    readonly frame: number;
+    readonly bodies: readonly DeterministicPhysicsBody2D[];
+    readonly activePairs: readonly string[];
+    readonly activePairMetadata: readonly DeterministicPhysicsActivePair2D[];
+}
+export interface DeterministicPhysicsActivePair2D {
+    readonly pair: string;
+    readonly a: string;
+    readonly b: string;
+    readonly sensor: boolean;
+    readonly trigger: boolean;
+    readonly material: DeterministicPhysicsMaterial;
+}
+export interface DeterministicPhysicsStepOptions2D {
+    readonly gravityX?: number;
+    readonly gravityY?: number;
+    readonly constraints?: readonly DeterministicPhysicsConstraint2D[];
+    readonly iterations?: number;
+}
+export interface DeterministicContactEvent2D {
+    readonly type: DeterministicContactEventType;
+    readonly pair: string;
+    readonly a: string;
+    readonly b: string;
+    readonly sensor: boolean;
+    readonly trigger: boolean;
+    readonly material: DeterministicPhysicsMaterial;
+}
+export interface DeterministicPhysicsStepResult2D {
+    readonly world: DeterministicPhysicsWorld2D;
+    readonly events: readonly DeterministicContactEvent2D[];
+    readonly broadphasePairs: number;
+    readonly narrowphaseContacts: number;
+    readonly solverIterations: number;
+    readonly checksum: string;
+}
+export interface DeterministicPhysicsQueryOptions2D {
+    readonly layerMask?: number;
+    readonly includeSensors?: boolean;
+    readonly includeTriggers?: boolean;
+    readonly hitStatics?: boolean;
+    readonly hitDynamics?: boolean;
+    readonly hitKinematics?: boolean;
+    readonly hitSolids?: boolean;
+    readonly hitSensors?: boolean;
+    readonly hitTriggers?: boolean;
+}
+export interface DeterministicPhysicsAabbQuery2D extends DeterministicPhysicsQueryOptions2D {
+    readonly x: number;
+    readonly y: number;
+    readonly halfWidth: number;
+    readonly halfHeight: number;
+}
+export interface DeterministicPhysicsRaycastQuery2D extends DeterministicPhysicsQueryOptions2D {
+    readonly x: number;
+    readonly y: number;
+    readonly dx: number;
+    readonly dy: number;
+    readonly maxDistance: number;
+}
+export interface DeterministicPhysicsShapeOverlapQuery2D extends DeterministicPhysicsQueryOptions2D {
+    readonly shape: 'aabb' | 'circle';
+    readonly x: number;
+    readonly y: number;
+    readonly z?: number;
+    readonly halfWidth?: number;
+    readonly halfHeight?: number;
+    readonly halfDepth?: number;
+    readonly radius?: number;
+}
+export interface DeterministicPhysicsCircleCastQuery2D extends DeterministicPhysicsQueryOptions2D {
+    readonly x: number;
+    readonly y: number;
+    readonly radius: number;
+    readonly dx: number;
+    readonly dy: number;
+    readonly maxDistance: number;
+}
+export interface DeterministicPhysicsHit2D {
+    readonly bodyId: string;
+    readonly distance: number;
+}
+export declare function createDeterministicPhysicsWorld2D(bodies: readonly DeterministicPhysicsBody2D[]): DeterministicPhysicsWorld2D;
+export declare function stepDeterministicPhysicsWorld2D(world: DeterministicPhysicsWorld2D, options?: DeterministicPhysicsStepOptions2D): DeterministicPhysicsStepResult2D;
+export declare function queryDeterministicPhysicsAabb2D(world: DeterministicPhysicsWorld2D, query: DeterministicPhysicsAabbQuery2D): readonly string[];
+export declare function raycastDeterministicPhysics2D(world: DeterministicPhysicsWorld2D, query: DeterministicPhysicsRaycastQuery2D): readonly DeterministicPhysicsHit2D[];
+export declare function raycastAllDeterministicPhysics2D(world: DeterministicPhysicsWorld2D, query: DeterministicPhysicsRaycastQuery2D): readonly DeterministicPhysicsHit2D[];
+export declare function nearestDeterministicPhysicsHit2D(world: DeterministicPhysicsWorld2D, query: DeterministicPhysicsRaycastQuery2D): DeterministicPhysicsHit2D | undefined;
+export declare function queryDeterministicPhysicsShapeOverlap2D(world: DeterministicPhysicsWorld2D, query: DeterministicPhysicsShapeOverlapQuery2D): readonly string[];
+export declare function circleCastDeterministicPhysics2D(world: DeterministicPhysicsWorld2D, query: DeterministicPhysicsCircleCastQuery2D): readonly DeterministicPhysicsHit2D[];