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

package/dist/cjs/physics-cert.js

@@ -0,0 +1,426 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPhysicsCert = runPhysicsCert;
+exports.runRapierPhysicsCert = runRapierPhysicsCert;
+const canonical_js_1 = require("./canonical.js");
+const collision_js_1 = require("./collision.js");
+const rapier2dCompatPackage = '@dimforge/rapier2d-compat';
+const physicsCertResults = {
+    true: 'pass',
+    false: 'fail',
+};
+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 = (0, canonical_js_1.defaultChecksum)(uninterrupted.collisionEvents) === (0, canonical_js_1.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),
+    };
+}
+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 = (0, canonical_js_1.defaultChecksum)(uninterrupted.collisionEvents) === (0, canonical_js_1.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 Promise.resolve(`${rapier2dCompatPackage}`).then(s => __importStar(require(s)));
+    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 && (0, canonical_js_1.defaultChecksum)(firstContacts.raw) === (0, canonical_js_1.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: (0, canonical_js_1.defaultChecksum)(Array.from(snapshot)),
+                second: (0, canonical_js_1.defaultChecksum)(Array.from(restored.takeSnapshot())),
+            });
+            world.free?.();
+            world = restored;
+        }
+    }
+    const finalSnapshot = world.takeSnapshot();
+    const finalChecksum = (0, canonical_js_1.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: (0, canonical_js_1.defaultChecksum)(snapshot), second: (0, canonical_js_1.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: (0, canonical_js_1.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: (0, collision_js_1.fixedCircle)((0, collision_js_1.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 ((0, collision_js_1.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 = (0, collision_js_1.fixedCircle)((0, collision_js_1.fixedVec2)(0, 0), 256);
+    return state.bodies
+        .filter((body) => (0, collision_js_1.circleIntersects)(origin, bodyToCircle(body)))
+        .map((body) => body.id)
+        .sort((left, right) => left.localeCompare(right));
+}
+function bodyToCircle(body) {
+    return (0, collision_js_1.fixedCircle)((0, collision_js_1.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');
+    }
+}