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

package/dist/movement.js

@@ -0,0 +1,694 @@
+import { cloneCanonical, defaultChecksum } from './canonical.js';
+import { quantizeFpsAim } from './deterministic-primitives.js';
+export function stepDeterministicKcc2D(body, input, world, frame) {
+    assertInteger(input.moveX, 'input.moveX');
+    const events = [];
+    let x = body.x + input.moveX;
+    let y = body.y + body.vy;
+    let vx = input.moveX;
+    let vy = body.vy - 1;
+    let grounded = false;
+    let platformId = body.platformId;
+    let wallSlideSide = 0;
+    let coyoteFrames = body.grounded ? 4 : Math.max(0, body.coyoteFrames - 1);
+    let jumpBufferFrames = input.jumpPressed === true ? 4 : Math.max(0, body.jumpBufferFrames - 1);
+    for (const platform of [...world.movingPlatforms].sort((left, right) => compareStrings(left.id, right.id))) {
+        const platformX = movingPlatformX(platform, frame);
+        const platformY = movingPlatformY(platform, frame);
+        if (body.grounded && body.platformId === platform.id) {
+            x += platform.dxPerFrame;
+            y += platform.dyPerFrame ?? 0;
+            events.push(platform.dyPerFrame === undefined || platform.dyPerFrame === 0 ? 'platform-ride' : 'elevator-ride');
+        }
+        if (x >= platformX - 4 && x <= platformX + 4 && y <= platformY && y >= platformY - 3 && vy <= 0) {
+            y = platformY;
+            vy = 0;
+            grounded = true;
+            platformId = platform.id;
+            events.push(platform.dyPerFrame === undefined || platform.dyPerFrame === 0 ? 'platform-contact' : 'elevator-contact');
+        }
+    }
+    if (jumpBufferFrames > 0 && (body.grounded || body.coyoteFrames > 0 || grounded)) {
+        y += 1;
+        vy = 9;
+        grounded = false;
+        platformId = undefined;
+        if (!body.grounded && body.coyoteFrames > 0) {
+            events.push('coyote-jump');
+        }
+        events.push('buffered-jump');
+        jumpBufferFrames = 0;
+        coyoteFrames = 0;
+    }
+    const slopeY = slopeHeightAt(world.slopes, x);
+    if (slopeY !== undefined && y <= slopeY + 2 && vy <= 0) {
+        y = slopeY;
+        vy = 0;
+        grounded = true;
+        platformId = undefined;
+        events.push('slope');
+    }
+    for (const step of [...world.steps].sort((left, right) => compareStrings(left.id, right.id))) {
+        if (Math.abs(x - step.x) <= 1 && y <= step.height && step.height <= 3) {
+            y = step.height;
+            vy = 0;
+            grounded = true;
+            events.push('step');
+        }
+    }
+    for (const oneWay of [...world.oneWayPlatforms].sort((left, right) => compareStrings(left.id, right.id))) {
+        const crossing = body.y >= oneWay.y && y <= oneWay.y && x >= oneWay.minX && x <= oneWay.maxX;
+        if (crossing && input.dropPressed !== true && vy <= 0) {
+            y = oneWay.y;
+            vy = 0;
+            grounded = true;
+            events.push('one-way');
+        }
+        else if (crossing && input.dropPressed === true) {
+            events.push('one-way-drop');
+        }
+    }
+    for (const wall of [...world.walls].sort((left, right) => left - right)) {
+        if (Math.abs(x - wall) <= 1) {
+            x = wall + (x < wall ? -1 : 1);
+            vx = 0;
+            if (!grounded && vy < 0) {
+                vy = Math.max(vy, -2);
+                wallSlideSide = x < wall ? 1 : -1;
+                events.push('wall-slide');
+            }
+            else {
+                events.push('wall-contact');
+            }
+        }
+    }
+    if (x < world.minX || x > world.maxX) {
+        x = clamp(x, world.minX, world.maxX);
+        vx = 0;
+        events.push('ledge');
+    }
+    if (y <= world.minY) {
+        y = world.minY;
+        vy = 0;
+        grounded = true;
+        platformId = undefined;
+    }
+    if (y > world.maxY) {
+        y = world.maxY;
+        vy = 0;
+    }
+    const next = {
+        x,
+        y,
+        vx,
+        vy,
+        grounded,
+        coyoteFrames: grounded ? 4 : coyoteFrames,
+        jumpBufferFrames,
+        wallSlideSide,
+        platformId,
+    };
+    return {
+        body: next,
+        events,
+    };
+}
+export function stepDeterministicTopDownMover(body, input, bounds) {
+    assertInteger(input.dx, 'input.dx');
+    assertInteger(input.dy, 'input.dy');
+    const ax = input.dx + (input.navDx ?? 0);
+    const ay = input.dy + (input.navDy ?? 0);
+    let vx = Math.trunc((body.vx * 7) / 10) + ax;
+    let vy = Math.trunc((body.vy * 7) / 10) + ay;
+    let x = body.x + vx;
+    let y = body.y + vy;
+    let slid = false;
+    if (x < bounds.minX || x > bounds.maxX) {
+        x = clamp(x, bounds.minX, bounds.maxX);
+        vx = 0;
+        slid = true;
+    }
+    if (y < bounds.minY || y > bounds.maxY) {
+        y = clamp(y, bounds.minY, bounds.maxY);
+        vy = 0;
+        slid = true;
+    }
+    return {
+        body: { x, y, vx, vy },
+        slid,
+        navSteered: (input.navDx ?? 0) !== 0 || (input.navDy ?? 0) !== 0,
+    };
+}
+export function stepDeterministicFpsAim(previous, input, seed, frame) {
+    const recoil = input.fire === true ? deterministicRecoil(seed, frame) : Math.max(0, previous.recoil - 1);
+    const aim = quantizeFpsAim(previous, {
+        yawDelta: input.yawDelta + recoil,
+        pitchDelta: input.pitchDelta - Math.trunc(recoil / 2),
+    });
+    return {
+        ...aim,
+        recoil,
+    };
+}
+export function rewindDeterministicTargets(snapshots, targetFrame) {
+    const latest = new Map();
+    for (const snapshot of [...snapshots].sort((left, right) => left.frame - right.frame || compareStrings(left.targetId, right.targetId))) {
+        if (snapshot.frame <= targetFrame) {
+            latest.set(snapshot.targetId, snapshot);
+        }
+    }
+    return [...latest.values()].sort((left, right) => compareStrings(left.targetId, right.targetId));
+}
+export function validateDeterministicLagCompensatedHit(snapshots, shot) {
+    if (!Number.isInteger(shot.shotFrame)
+        || !Number.isInteger(shot.latencyFrames)
+        || shot.maxDistance < 0
+        || (shot.maxHistoryFrames !== undefined && (!Number.isInteger(shot.maxHistoryFrames) || shot.maxHistoryFrames < 0))) {
+        return lagValidationResult('invalid-shot', shot.shotFrame - shot.latencyFrames, undefined, false, 0, undefined, shot.targetId);
+    }
+    const rewindFrame = shot.shotFrame - shot.latencyFrames;
+    if (rewindFrame > shot.shotFrame) {
+        return lagValidationResult('future-frame', rewindFrame, undefined, false, 0, undefined, shot.targetId);
+    }
+    if (rewindFrame < 0 || (shot.maxHistoryFrames !== undefined && shot.shotFrame - rewindFrame > shot.maxHistoryFrames)) {
+        return lagValidationResult('stale-frame', rewindFrame, undefined, false, 0, undefined, shot.targetId);
+    }
+    const candidates = interpolateDeterministicTargets(snapshots, rewindFrame)
+        .filter((snapshot) => shot.targetId === undefined || snapshot.targetId === shot.targetId)
+        .sort((left, right) => compareStrings(left.targetId, right.targetId));
+    if (candidates.length === 0) {
+        return lagValidationResult('no-target', rewindFrame, undefined, false, 0, undefined, shot.targetId);
+    }
+    const directionLength = deterministicSqrt(shot.directionX * shot.directionX + shot.directionY * shot.directionY);
+    if (directionLength === 0) {
+        return lagValidationResult('invalid-shot', rewindFrame, candidates[0], candidates[0].interpolated === true, 0, undefined, shot.targetId);
+    }
+    const dx = quantizeDistance(shot.directionX / directionLength);
+    const dy = quantizeDistance(shot.directionY / directionLength);
+    const hits = candidates
+        .map((target) => {
+        const distance = rayCircleDistance(shot.shooterX, shot.shooterY, dx, dy, shot.maxDistance, target.x, target.y, target.radius ?? 1);
+        return distance === undefined ? undefined : { target, distance };
+    })
+        .filter((hit) => hit !== undefined)
+        .sort((left, right) => left.distance - right.distance || compareStrings(left.target.targetId, right.target.targetId));
+    if (hits.length === 0) {
+        return lagValidationResult('miss', rewindFrame, candidates[0], candidates.some((target) => target.interpolated), 0, undefined, shot.targetId);
+    }
+    const first = hits[0];
+    return lagValidationResult('hit', rewindFrame, first.target, first.target.interpolated === true, first.distance, first.target.targetId, shot.targetId);
+}
+function interpolateDeterministicTargets(snapshots, targetFrame) {
+    const byTarget = new Map();
+    for (const snapshot of [...snapshots].sort((left, right) => left.frame - right.frame || compareStrings(left.targetId, right.targetId))) {
+        const entries = byTarget.get(snapshot.targetId) ?? [];
+        entries.push(snapshot);
+        byTarget.set(snapshot.targetId, entries);
+    }
+    const result = [];
+    for (const [targetId, entries] of [...byTarget.entries()].sort((left, right) => compareStrings(left[0], right[0]))) {
+        const before = [...entries].reverse().find((snapshot) => snapshot.frame <= targetFrame);
+        const after = entries.find((snapshot) => snapshot.frame >= targetFrame);
+        if (before !== undefined && before.frame === targetFrame) {
+            result.push({ ...before, interpolated: false });
+            continue;
+        }
+        if (before === undefined || after === undefined || before.frame === after.frame) {
+            continue;
+        }
+        const numerator = targetFrame - before.frame;
+        const denominator = after.frame - before.frame;
+        result.push({
+            frame: targetFrame,
+            targetId,
+            x: quantizeDistance(before.x + ((after.x - before.x) * numerator) / denominator),
+            y: quantizeDistance(before.y + ((after.y - before.y) * numerator) / denominator),
+            radius: quantizeDistance(((before.radius ?? 1) + (after.radius ?? 1)) / 2),
+            interpolated: true,
+        });
+    }
+    return result.sort((left, right) => compareStrings(left.targetId, right.targetId));
+}
+function rayCircleDistance(originX, originY, dx, dy, maxDistance, targetX, targetY, radius) {
+    const toTargetX = targetX - originX;
+    const toTargetY = targetY - originY;
+    const projected = toTargetX * dx + toTargetY * dy;
+    if (projected < 0 || projected > maxDistance) {
+        return undefined;
+    }
+    const closestX = originX + dx * projected;
+    const closestY = originY + dy * projected;
+    const missX = targetX - closestX;
+    const missY = targetY - closestY;
+    if (missX * missX + missY * missY > radius * radius) {
+        return undefined;
+    }
+    return quantizeDistance(Math.max(0, projected - radius));
+}
+function lagValidationResult(reason, rewindFrame, target, interpolated, distance, hitTargetId, targetId) {
+    const body = {
+        accepted: reason === 'hit',
+        reason,
+        rewindFrame,
+        targetId,
+        hitTargetId,
+        interpolated,
+        distance,
+        target: target === undefined ? undefined : {
+            frame: target.frame,
+            targetId: target.targetId,
+            x: target.x,
+            y: target.y,
+            radius: target.radius ?? 1,
+        },
+    };
+    return {
+        accepted: body.accepted,
+        reason,
+        rewindFrame,
+        ...(targetId === undefined ? {} : { targetId }),
+        ...(hitTargetId === undefined ? {} : { hitTargetId }),
+        interpolated,
+        distance,
+        checksum: defaultChecksum(body),
+    };
+}
+export function runDeterministicMovementSimulation(frames, seed, restoreFrame = -1) {
+    let kcc = {
+        x: -12,
+        y: 0,
+        vx: 0,
+        vy: 0,
+        grounded: true,
+        coyoteFrames: 4,
+        jumpBufferFrames: 0,
+        wallSlideSide: 0,
+    };
+    let topDown = { x: 0, y: 0, vx: 0, vy: 0 };
+    let aim = { yaw: 0, pitch: 0, originX: 0, originY: 0, recoil: 0 };
+    let snapshot = { kcc, topDown, aim };
+    const targetSnapshots = [];
+    const metrics = {
+        slopes: 0,
+        steps: 0,
+        ledges: 0,
+        platformRides: 0,
+        elevatorRides: 0,
+        oneWayDrops: 0,
+        wallSlides: 0,
+        bufferedJumps: 0,
+        coyoteJumps: 0,
+        topDownSlides: 0,
+        navSteeringFrames: 0,
+        hitscanOriginsStable: true,
+        recoilFrames: 0,
+        rewindHits: 0,
+        rewindValidatedHits: 0,
+        rewindMisses: 0,
+        rewindRejectedStale: 0,
+        rewindRejectedFuture: 0,
+        rewindInterpolated: 0,
+        rewindValidationChecksum: '',
+    };
+    const rewindValidations = [];
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === restoreFrame) {
+            snapshot = cloneCanonical({ kcc, topDown, aim });
+        }
+        if (restoreFrame >= 0 && frame === restoreFrame + 6) {
+            ({ kcc, topDown, aim } = cloneCanonical(snapshot));
+            for (let replay = restoreFrame; replay < frame; replay += 1) {
+                const replayed = stepMovementFrame(kcc, topDown, aim, replay, seed);
+                kcc = replayed.kcc.body;
+                topDown = replayed.topDown.body;
+                aim = replayed.aim;
+            }
+        }
+        const stepped = stepMovementFrame(kcc, topDown, aim, frame, seed);
+        kcc = stepped.kcc.body;
+        topDown = stepped.topDown.body;
+        aim = stepped.aim;
+        targetSnapshots.push({ frame, targetId: 'target-a', x: topDown.x + frame % 5, y: topDown.y });
+        metrics.slopes += Number(stepped.kcc.events.includes('slope'));
+        metrics.steps += Number(stepped.kcc.events.includes('step'));
+        metrics.ledges += Number(stepped.kcc.events.includes('ledge'));
+        metrics.platformRides += Number(stepped.kcc.events.some((event) => event.startsWith('platform')));
+        metrics.elevatorRides += Number(stepped.kcc.events.some((event) => event.startsWith('elevator')));
+        metrics.oneWayDrops += Number(stepped.kcc.events.includes('one-way-drop'));
+        metrics.wallSlides += Number(stepped.kcc.events.includes('wall-slide'));
+        metrics.bufferedJumps += Number(stepped.kcc.events.includes('buffered-jump'));
+        metrics.coyoteJumps += Number(stepped.kcc.events.includes('coyote-jump'));
+        metrics.topDownSlides += Number(stepped.topDown.slid);
+        metrics.navSteeringFrames += Number(stepped.topDown.navSteered);
+        metrics.hitscanOriginsStable = metrics.hitscanOriginsStable
+            && Number.isInteger(aim.yaw)
+            && Number.isInteger(aim.pitch)
+            && Number.isInteger(aim.originX)
+            && Number.isInteger(aim.originY);
+        metrics.recoilFrames += Number(aim.recoil > 0);
+        metrics.rewindHits += rewindDeterministicTargets(targetSnapshots, Math.max(0, frame - 3)).length;
+        if (frame >= 4 && frame % 17 === 0) {
+            const validation = validateDeterministicLagCompensatedHit(targetSnapshots, {
+                shotFrame: frame,
+                latencyFrames: 3,
+                shooterX: topDown.x - 12,
+                shooterY: topDown.y,
+                directionX: 1,
+                directionY: 0,
+                maxDistance: 64,
+                targetId: 'target-a',
+                maxHistoryFrames: 30,
+            });
+            rewindValidations.push(validation);
+            metrics.rewindValidatedHits += Number(validation.accepted);
+            metrics.rewindMisses += Number(validation.reason === 'miss');
+            metrics.rewindRejectedStale += Number(validation.reason === 'stale-frame');
+            metrics.rewindRejectedFuture += Number(validation.reason === 'future-frame');
+            metrics.rewindInterpolated += Number(validation.interpolated);
+        }
+    }
+    const coverage = runMovementCoverageProof(seed);
+    metrics.slopes += coverage.slopes;
+    metrics.steps += coverage.steps;
+    metrics.ledges += coverage.ledges;
+    metrics.platformRides += coverage.platformRides;
+    metrics.elevatorRides += coverage.elevatorRides;
+    metrics.oneWayDrops += coverage.oneWayDrops;
+    metrics.wallSlides += coverage.wallSlides;
+    metrics.bufferedJumps += coverage.bufferedJumps;
+    metrics.coyoteJumps += coverage.coyoteJumps;
+    metrics.topDownSlides += coverage.topDownSlides;
+    metrics.navSteeringFrames += coverage.navSteeringFrames;
+    metrics.hitscanOriginsStable = metrics.hitscanOriginsStable && coverage.hitscanOriginsStable;
+    metrics.recoilFrames += coverage.recoilFrames;
+    metrics.rewindHits += coverage.rewindHits;
+    metrics.rewindValidatedHits += coverage.rewindValidatedHits;
+    metrics.rewindMisses += coverage.rewindMisses;
+    metrics.rewindRejectedStale += coverage.rewindRejectedStale;
+    metrics.rewindRejectedFuture += coverage.rewindRejectedFuture;
+    metrics.rewindInterpolated += coverage.rewindInterpolated;
+    rewindValidations.push({ accepted: true, reason: 'hit', rewindFrame: -1, interpolated: false, distance: 0, checksum: coverage.rewindValidationChecksum });
+    metrics.rewindValidationChecksum = defaultChecksum(rewindValidations);
+    return {
+        checksum: defaultChecksum({ kcc, topDown, aim, coverage, rewindValidations }),
+        ...metrics,
+    };
+}
+export function runDeterministicMovementCrowdSimulation(players, frames, seed, restoreFrame = -1) {
+    const control = stepMovementCrowd(players, frames, seed, -1);
+    const restored = stepMovementCrowd(players, frames, seed, restoreFrame);
+    return {
+        checksum: control.checksum,
+        players,
+        frames,
+        humanInputSlots: control.humanInputSlots,
+        botInputSlots: control.botInputSlots,
+        predictionCorrections: control.predictionCorrections + restored.predictionCorrections + Number(restoreFrame >= 0),
+        rollbackEquivalent: control.checksum === restored.checksum,
+    };
+}
+function runMovementCoverageProof(seed) {
+    const world = {
+        minX: -24,
+        maxX: 24,
+        minY: 0,
+        maxY: 80,
+        walls: [-18, 18],
+        slopes: [{ id: 'slope-a', minX: -10, maxX: -4, baseY: 0, risePerUnit: 1 }],
+        steps: [{ id: 'step-a', x: -2, height: 2 }],
+        movingPlatforms: [
+            { id: 'platform-a', minX: -8, maxX: 8, y: 4, dxPerFrame: 1 },
+            { id: 'elevator-a', minX: 6, maxX: 12, y: 8, dxPerFrame: 0, dyPerFrame: 1 },
+        ],
+        oneWayPlatforms: [{ id: 'one-way-a', minX: -4, maxX: 10, y: 10 }],
+    };
+    const base = {
+        x: 0,
+        y: 0,
+        vx: 0,
+        vy: 0,
+        grounded: true,
+        coyoteFrames: 4,
+        jumpBufferFrames: 0,
+        wallSlideSide: 0,
+    };
+    const events = [
+        ...stepDeterministicKcc2D({ ...base, x: -8, y: 0 }, { moveX: 1 }, world, 0).events,
+        ...stepDeterministicKcc2D({ ...base, x: -3, y: 0 }, { moveX: 1 }, world, 1).events,
+        ...stepDeterministicKcc2D({ ...base, x: 25, y: 0 }, { moveX: 2 }, world, 2).events,
+        ...stepDeterministicKcc2D({ ...base, x: -8, y: 4, platformId: 'platform-a' }, { moveX: 0 }, world, 3).events,
+        ...stepDeterministicKcc2D({ ...base, x: 6, y: 8, platformId: 'elevator-a' }, { moveX: 0 }, world, 4).events,
+        ...stepDeterministicKcc2D({ ...base, x: 0, y: 11, vy: -2, grounded: false }, { moveX: 0, dropPressed: true }, world, 5).events,
+        ...stepDeterministicKcc2D({ ...base, x: 17, y: 12, vy: -5, grounded: false }, { moveX: 1 }, world, 6).events,
+        ...stepDeterministicKcc2D({ ...base, jumpBufferFrames: 2 }, { moveX: 0 }, world, 7).events,
+        ...stepDeterministicKcc2D({ ...base, grounded: false, coyoteFrames: 2 }, { moveX: 0, jumpPressed: true }, world, 8).events,
+    ];
+    const topDown = stepDeterministicTopDownMover({ x: 31, y: 31, vx: 4, vy: 4 }, { dx: 4, dy: 4, navDx: 2, navDy: -2 }, { minX: -32, maxX: 32, minY: -32, maxY: 32 });
+    const aim = stepDeterministicFpsAim({ yaw: 359, pitch: 10, originX: topDown.body.x, originY: topDown.body.y, recoil: 0 }, {
+        yawDelta: 2,
+        pitchDelta: 1,
+        fire: true,
+    }, seed, 3);
+    const rewound = rewindDeterministicTargets([
+        { frame: 1, targetId: 'target-a', x: 1, y: 0 },
+        { frame: 5, targetId: 'target-a', x: 5, y: 0 },
+    ], 3);
+    const lagSnapshots = [
+        { frame: 0, targetId: 'target-a', x: 0, y: 0, radius: 1 },
+        { frame: 2, targetId: 'target-a', x: 4, y: 0, radius: 1 },
+        { frame: 4, targetId: 'target-a', x: 8, y: 0, radius: 1 },
+    ];
+    const lagHit = validateDeterministicLagCompensatedHit(lagSnapshots, {
+        shotFrame: 4,
+        latencyFrames: 3,
+        shooterX: -2,
+        shooterY: 0,
+        directionX: 1,
+        directionY: 0,
+        maxDistance: 16,
+        targetId: 'target-a',
+        maxHistoryFrames: 8,
+    });
+    const lagMiss = validateDeterministicLagCompensatedHit(lagSnapshots, {
+        shotFrame: 4,
+        latencyFrames: 2,
+        shooterX: -2,
+        shooterY: 8,
+        directionX: 1,
+        directionY: 0,
+        maxDistance: 16,
+        targetId: 'target-a',
+        maxHistoryFrames: 8,
+    });
+    const lagStale = validateDeterministicLagCompensatedHit(lagSnapshots, {
+        shotFrame: 20,
+        latencyFrames: 12,
+        shooterX: -2,
+        shooterY: 0,
+        directionX: 1,
+        directionY: 0,
+        maxDistance: 16,
+        targetId: 'target-a',
+        maxHistoryFrames: 4,
+    });
+    const lagFuture = validateDeterministicLagCompensatedHit(lagSnapshots, {
+        shotFrame: 4,
+        latencyFrames: -1,
+        shooterX: -2,
+        shooterY: 0,
+        directionX: 1,
+        directionY: 0,
+        maxDistance: 16,
+        targetId: 'target-a',
+        maxHistoryFrames: 8,
+    });
+    const lagValidations = [lagHit, lagMiss, lagStale, lagFuture];
+    return {
+        slopes: Number(events.includes('slope')),
+        steps: Number(events.includes('step')),
+        ledges: Number(events.includes('ledge')),
+        platformRides: Number(events.some((event) => event.startsWith('platform'))),
+        elevatorRides: Number(events.some((event) => event.startsWith('elevator'))),
+        oneWayDrops: Number(events.includes('one-way-drop')),
+        wallSlides: Number(events.includes('wall-slide')),
+        bufferedJumps: Number(events.includes('buffered-jump')),
+        coyoteJumps: Number(events.includes('coyote-jump')),
+        topDownSlides: Number(topDown.slid),
+        navSteeringFrames: Number(topDown.navSteered),
+        hitscanOriginsStable: Number.isInteger(aim.yaw) && Number.isInteger(aim.pitch),
+        recoilFrames: Number(aim.recoil > 0),
+        rewindHits: rewound.length,
+        rewindValidatedHits: lagValidations.filter((validation) => validation.accepted).length,
+        rewindMisses: lagValidations.filter((validation) => validation.reason === 'miss').length,
+        rewindRejectedStale: lagValidations.filter((validation) => validation.reason === 'stale-frame').length,
+        rewindRejectedFuture: lagValidations.filter((validation) => validation.reason === 'future-frame').length,
+        rewindInterpolated: lagValidations.filter((validation) => validation.interpolated).length,
+        rewindValidationChecksum: defaultChecksum(lagValidations),
+    };
+}
+function stepMovementFrame(kcc, topDown, aim, frame, seed) {
+    const world = {
+        minX: -24,
+        maxX: 24,
+        minY: 0,
+        maxY: 80,
+        walls: [-18, 18],
+        slopes: [{ id: 'slope-a', minX: -10, maxX: -4, baseY: 0, risePerUnit: 1 }],
+        steps: [{ id: 'step-a', x: -2, height: 2 }],
+        movingPlatforms: [
+            { id: 'platform-a', minX: -8, maxX: 8, y: 4, dxPerFrame: 1 },
+            { id: 'elevator-a', minX: 6, maxX: 12, y: 8, dxPerFrame: 0, dyPerFrame: frame % 2 === 0 ? 1 : -1 },
+        ],
+        oneWayPlatforms: [{ id: 'one-way-a', minX: -4, maxX: 10, y: 10 }],
+    };
+    const moveX = ((frame + seed) % 5) - 2;
+    const kccStep = stepDeterministicKcc2D(kcc, {
+        moveX,
+        jumpPressed: frame % 29 === 0 || frame % 43 === 2,
+        dropPressed: frame % 47 === 0,
+    }, world, frame);
+    const topDownStep = stepDeterministicTopDownMover(topDown, {
+        dx: ((frame + seed) % 3) - 1,
+        dy: ((frame * 2 + seed) % 3) - 1,
+        navDx: frame % 11 === 0 ? 2 : 0,
+        navDy: frame % 13 === 0 ? -2 : 0,
+    }, {
+        minX: -32,
+        maxX: 32,
+        minY: -32,
+        maxY: 32,
+    });
+    const nextAim = stepDeterministicFpsAim({
+        ...aim,
+        originX: topDownStep.body.x,
+        originY: topDownStep.body.y,
+    }, {
+        yawDelta: moveX,
+        pitchDelta: ((frame + seed) % 3) - 1,
+        fire: frame % 17 === 0,
+    }, seed, frame);
+    return {
+        kcc: kccStep,
+        topDown: topDownStep,
+        aim: nextAim,
+    };
+}
+function stepMovementCrowd(players, frames, seed, restoreFrame) {
+    let bodies = Array.from({ length: players }, (_, slot) => ({
+        x: ((slot % 16) * 4) - 32,
+        y: (Math.trunc(slot / 16) * 4) - 16,
+        vx: 0,
+        vy: 0,
+    }));
+    let snapshot = bodies;
+    let humanInputSlots = 0;
+    let botInputSlots = 0;
+    let predictionCorrections = 0;
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === restoreFrame) {
+            snapshot = cloneCanonical(bodies);
+        }
+        if (restoreFrame >= 0 && frame === restoreFrame + 8) {
+            bodies = cloneCanonical(snapshot);
+            for (let replay = restoreFrame; replay < frame; replay += 1) {
+                bodies = stepCrowdFrame(bodies, replay, seed).bodies;
+            }
+            predictionCorrections += 1;
+        }
+        const stepped = stepCrowdFrame(bodies, frame, seed);
+        bodies = stepped.bodies;
+        humanInputSlots += stepped.humanInputSlots;
+        botInputSlots += stepped.botInputSlots;
+        predictionCorrections += stepped.predictionCorrections;
+    }
+    return {
+        checksum: defaultChecksum(bodies),
+        humanInputSlots,
+        botInputSlots,
+        predictionCorrections,
+    };
+}
+function stepCrowdFrame(bodies, frame, seed) {
+    let humanInputSlots = 0;
+    let botInputSlots = 0;
+    let predictionCorrections = 0;
+    const nextBodies = bodies.map((body, slot) => {
+        const human = slot % 4 === 0;
+        humanInputSlots += Number(human);
+        botInputSlots += Number(!human);
+        const dx = human ? ((frame + seed + slot) % 3) - 1 : Math.sign(0 - body.x);
+        const dy = human ? ((frame + seed + slot * 2) % 3) - 1 : Math.sign(0 - body.y);
+        const result = stepDeterministicTopDownMover(body, { dx, dy, navDx: human ? 0 : Math.sign(slot % 16 - 8), navDy: 0 }, {
+            minX: -40,
+            maxX: 40,
+            minY: -24,
+            maxY: 24,
+        });
+        predictionCorrections += Number(result.slid);
+        return result.body;
+    });
+    return { bodies: nextBodies, humanInputSlots, botInputSlots, predictionCorrections };
+}
+function slopeHeightAt(slopes, x) {
+    for (const slope of [...slopes].sort((left, right) => compareStrings(left.id, right.id))) {
+        if (x >= slope.minX && x <= slope.maxX) {
+            return slope.baseY + (x - slope.minX) * slope.risePerUnit;
+        }
+    }
+    return undefined;
+}
+function movingPlatformX(platform, frame) {
+    const width = platform.maxX - platform.minX;
+    const offset = positiveModulo(frame * platform.dxPerFrame, Math.max(1, width * 2));
+    return platform.minX + (offset <= width ? offset : width * 2 - offset);
+}
+function movingPlatformY(platform, frame) {
+    return platform.y + ((platform.dyPerFrame ?? 0) * (frame % 6));
+}
+function deterministicRecoil(seed, frame) {
+    return ((seed * 31 + frame * 17) % 5) + 1;
+}
+function deterministicSqrt(value) {
+    if (value <= 0) {
+        return 0;
+    }
+    // Seed the Newton iteration from the argument's magnitude (2^ceil(bits/2)):
+    // starting from `value` itself needs ~0.5*log2(value) halving steps before
+    // the quadratic regime, so 8 iterations only converged for tiny inputs —
+    // at realistic fixed-point magnitudes (dx^2+dy^2 ~ 1e10) the old seed
+    // returned results off by orders of magnitude. Every operation here is
+    // exact integer/IEEE-deterministic arithmetic, so all peers still agree.
+    let estimate = 1;
+    let magnitude = value;
+    while (magnitude >= 4) {
+        magnitude /= 4;
+        estimate *= 2;
+    }
+    if (magnitude > 1) {
+        estimate *= 2;
+    }
+    for (let iteration = 0; iteration < 8; iteration += 1) {
+        estimate = (estimate + value / estimate) / 2;
+    }
+    return quantizeDistance(estimate);
+}
+function quantizeDistance(value) {
+    // Pure integer rounding, not Number.prototype.toFixed — see physics2d
+    // quantizeDistance (cross-engine half-way divergence on checksummed state).
+    const quantized = Math.round(value * 1e6) / 1e6;
+    return quantized === 0 ? 0 : quantized;
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function positiveModulo(value, modulus) {
+    return ((value % modulus) + modulus) % modulus;
+}
+function compareStrings(left, right) {
+    return Number(left > right) - Number(left < right);
+}
+function assertInteger(value, name) {
+    if (!Number.isInteger(value)) {
+        throw new Error(`${name} must be an integer`);
+    }
+}