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

package/dist/deterministic-primitives.js

@@ -0,0 +1,126 @@
+import { canonicalStringify, defaultChecksum } from './canonical.js';
+const defaultMaterial = {
+    friction: 0,
+    restitution: 0,
+};
+export function detectVerticalCcdHit(startX, endX, wallX) {
+    assertInteger(startX, 'startX');
+    assertInteger(endX, 'endX');
+    assertInteger(wallX, 'wallX');
+    return Math.min(startX, endX) <= wallX && Math.max(startX, endX) >= wallX;
+}
+export function combineDeterministicPhysicsMaterial(left, right) {
+    assertInteger(left.friction, 'left.friction');
+    assertInteger(right.friction, 'right.friction');
+    assertInteger(left.restitution, 'left.restitution');
+    assertInteger(right.restitution, 'right.restitution');
+    return {
+        friction: Math.floor((left.friction + right.friction) / 2),
+        restitution: Math.max(left.restitution, right.restitution),
+    };
+}
+export function cookStaticColliders(colliders) {
+    const ids = new Set();
+    const cooked = colliders.map((collider) => {
+        if (ids.has(collider.id)) {
+            throw new Error(`Duplicate static collider id ${collider.id}`);
+        }
+        ids.add(collider.id);
+        assertInteger(collider.x, `${collider.id}.x`);
+        assertInteger(collider.y, `${collider.id}.y`);
+        assertInteger(collider.halfWidth, `${collider.id}.halfWidth`);
+        assertInteger(collider.halfHeight, `${collider.id}.halfHeight`);
+        return {
+            id: collider.id,
+            x: collider.x,
+            y: collider.y,
+            halfWidth: collider.halfWidth,
+            halfHeight: collider.halfHeight,
+            material: collider.material ?? defaultMaterial,
+        };
+    }).sort((left, right) => compareUniqueStrings(left.id, right.id));
+    const bytes = canonicalStringify(cooked);
+    return {
+        schemaVersion: 1,
+        hash: defaultChecksum(cooked),
+        bytes,
+        colliders: cooked,
+    };
+}
+function compareUniqueStrings(left, right) {
+    return left < right ? -1 : 1;
+}
+export function stepTopDownBody(body, input, bounds) {
+    assertInteger(input.dx, 'input.dx');
+    const dy = input.dy ?? 0;
+    assertInteger(dy, 'input.dy');
+    let x = body.x + input.dx;
+    let y = body.y + dy;
+    let vx = input.dx;
+    let vy = dy;
+    if (x < bounds.minX || x > bounds.maxX) {
+        x = clamp(x, bounds.minX, bounds.maxX);
+        vx = 0;
+    }
+    if (y < bounds.minY || y > bounds.maxY) {
+        y = clamp(y, bounds.minY, bounds.maxY);
+        vy = 0;
+    }
+    return {
+        x,
+        y,
+        vx,
+        vy,
+        grounded: body.grounded,
+    };
+}
+export function stepKccLiteBody(body, input) {
+    assertInteger(input.dx, 'input.dx');
+    let x = body.x + input.dx;
+    let y = body.y + body.vy;
+    let vy = body.vy - 1;
+    if (input.jump === true && body.grounded) {
+        vy = 7;
+        y += 1;
+    }
+    if (x > 24) {
+        x = 24;
+    }
+    if (x < -24) {
+        x = -24;
+    }
+    if (y <= 0) {
+        y = 0;
+        vy = 0;
+    }
+    return {
+        x,
+        y,
+        vx: input.dx,
+        vy,
+        grounded: y === 0,
+    };
+}
+export function quantizeFpsAim(previous, input) {
+    assertInteger(input.yawDelta, 'input.yawDelta');
+    assertInteger(input.pitchDelta, 'input.pitchDelta');
+    const yaw = positiveModulo(previous.yaw + input.yawDelta, 360);
+    const pitch = clamp(previous.pitch + input.pitchDelta, -89, 89);
+    return {
+        yaw,
+        pitch,
+        originX: previous.originX,
+        originY: previous.originY,
+    };
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function positiveModulo(value, modulus) {
+    return ((value % modulus) + modulus) % modulus;
+}
+function assertInteger(value, name) {
+    if (!Number.isInteger(value)) {
+        throw new Error(`${name} must be an integer`);
+    }
+}

package/dist/deterministic-session.d.ts

@@ -0,0 +1,197 @@
+import { type CanonicalValue } from './canonical.js';
+import { type DeterministicPayloadFieldDescriptor, type DeterministicCommandChannelDescriptor, type DeterministicPlayerCommand, type DeterministicRejectedCommand } from './commands.js';
+import { type DeterministicComponentData, type DeterministicFrameRuntimeDescriptor, type DeterministicFrameSnapshot, type DeterministicSystem } from './engine-runtime.js';
+export type DeterministicSessionInputFlag = 'repeatable' | 'player-not-present' | 'replaced-by-server' | 'command';
+export interface DeterministicSessionInput {
+    readonly frame: number;
+    readonly slot: number;
+    readonly value: number;
+    readonly data?: CanonicalValue;
+    readonly flags?: readonly DeterministicSessionInputFlag[];
+}
+export interface DeterministicSessionPlayer {
+    readonly slot: number;
+    readonly actorId: string;
+    readonly active: boolean;
+    readonly spectator: boolean;
+    readonly joinedFrame: number;
+    readonly removedFrame?: number;
+}
+export interface DeterministicSessionLifecycleEvent {
+    readonly frame: number;
+    readonly type: 'join-spectator' | 'add-player' | 'remove-player';
+    readonly slot: number;
+    readonly actorId: string;
+    readonly accepted: boolean;
+    readonly reason?: string;
+}
+export interface DeterministicSessionOptions {
+    readonly players: number;
+    readonly descriptor: DeterministicFrameRuntimeDescriptor;
+    readonly systems: Readonly<Record<string, DeterministicSystem>>;
+    readonly seed?: number;
+    readonly inputSingletonId?: string;
+    readonly mapInputsToSingleton?: (frame: number, inputs: readonly DeterministicSessionInput[], players: readonly DeterministicSessionPlayer[], commands: readonly DeterministicPlayerCommand[]) => DeterministicComponentData;
+    readonly commandChannels?: readonly DeterministicCommandChannelDescriptor[];
+    readonly validCommandAssetRefs?: readonly string[];
+    readonly validateCommandPayload?: (command: DeterministicPlayerCommand) => boolean;
+    readonly inputDataFields?: readonly DeterministicPayloadFieldDescriptor[];
+    readonly reconnectGraceFrames?: number;
+}
+export interface DeterministicSessionSnapshot {
+    readonly verifiedFrame: DeterministicFrameSnapshot;
+    readonly predictedFrame: DeterministicFrameSnapshot;
+    readonly predictedPreviousFrame?: DeterministicFrameSnapshot;
+    readonly players: readonly DeterministicSessionPlayer[];
+    readonly confirmedInputs: readonly DeterministicSessionInput[];
+    readonly predictedInputs: readonly DeterministicSessionInput[];
+    readonly replacementInputs: readonly DeterministicSessionInput[];
+    readonly confirmedCommands: readonly DeterministicPlayerCommand[];
+    readonly predictedCommands: readonly DeterministicPlayerCommand[];
+    readonly rejectedCommands: readonly DeterministicRejectedCommand[];
+    readonly lifecycleEvents: readonly DeterministicSessionLifecycleEvent[];
+    readonly correctionCount: number;
+    readonly replacementInputCount: number;
+    readonly checksum: string;
+}
+export interface DeterministicSessionReplayBundle {
+    readonly schemaVersion: 1;
+    readonly descriptorHash: string;
+    readonly runtimeVersion: string;
+    readonly players: number;
+    readonly seed: number;
+    readonly inputSingletonId: string;
+    readonly confirmedInputs: readonly DeterministicSessionInput[];
+    readonly replacementInputs: readonly DeterministicSessionInput[];
+    readonly confirmedCommands: readonly DeterministicPlayerCommand[];
+    readonly lifecycleEvents: readonly DeterministicSessionLifecycleEvent[];
+    readonly verifiedChecksums: readonly {
+        readonly frame: number;
+        readonly checksum: string;
+    }[];
+    readonly finalVerifiedChecksum: string;
+    readonly checksum: string;
+}
+export interface DeterministicSessionReplayVerification {
+    readonly result: 'pass' | 'fail';
+    readonly replayChecksum: string;
+    readonly expectedChecksum: string;
+    readonly actualChecksum: string;
+    readonly verifiedFrames: number;
+    readonly firstMismatchFrame: number;
+}
+export interface DeterministicSessionCore {
+    readonly players: readonly DeterministicSessionPlayer[];
+    readonly frameVerified: DeterministicFrameSnapshot;
+    readonly framePredicted: DeterministicFrameSnapshot;
+    readonly framePredictedPrevious: DeterministicFrameSnapshot | undefined;
+    readonly correctionCount: number;
+    readonly replacementInputCount: number;
+    joinAsSpectator(slot: number, actorId: string, frame?: number): DeterministicSessionLifecycleEvent;
+    addPlayer(slot: number, actorId: string, frame?: number): DeterministicSessionLifecycleEvent;
+    removePlayer(slot: number, actorId: string, frame?: number): DeterministicSessionLifecycleEvent;
+    submitPredictedInput(input: DeterministicSessionInput): void;
+    confirmInput(input: DeterministicSessionInput): void;
+    replaceInput(input: DeterministicSessionInput): void;
+    submitPredictedCommand(command: DeterministicPlayerCommand): DeterministicRejectedCommand | undefined;
+    confirmCommand(command: DeterministicPlayerCommand): DeterministicRejectedCommand | undefined;
+    pollCommands(frame: number, slot?: number, channelId?: string): readonly DeterministicPlayerCommand[];
+    predictTo(frameExclusive: number): void;
+    advanceVerifiedTo(frameExclusive: number): void;
+    applyCorrection(snapshot: DeterministicFrameSnapshot): boolean;
+    isFrameVerified(frame: number): boolean;
+    getInputFlags(frame: number, slot: number): readonly DeterministicSessionInputFlag[];
+    snapshot(): DeterministicSessionSnapshot;
+    exportReplay(): DeterministicSessionReplayBundle;
+}
+export interface DeterministicSessionCoreFixtureResult {
+    readonly checksum: string;
+    readonly players: number;
+    readonly frames: number;
+    readonly verifiedFrame: number;
+    readonly predictedFrame: number;
+    readonly verifiedChecksum: string;
+    readonly predictedChecksum: string;
+    readonly replayChecksum: string;
+    readonly replayVerified: boolean;
+    readonly replayFirstMismatchFrame: number;
+    readonly correctionCount: number;
+    readonly staleCorrectionsRejected: number;
+    readonly replacementInputs: number;
+    readonly repeatableInputs: number;
+    readonly playerNotPresentInputs: number;
+    readonly serverReplacedInputs: number;
+    readonly commandFlagInputs: number;
+    readonly predictedCommands: number;
+    readonly confirmedCommands: number;
+    readonly rejectedCommands: number;
+    readonly commandReplayVerified: boolean;
+    readonly commandSystemPolls: number;
+    readonly lifecycleEvents: number;
+    readonly addPlayerAccepted: number;
+    readonly removePlayerAccepted: number;
+    readonly duplicateAddRejected: number;
+    readonly removedSlotInputRejected: number;
+    readonly partialConfirmationHeldVerifiedFrame: boolean;
+    readonly predictedPreviousAvailable: boolean;
+    readonly frameRingExposed: boolean;
+    readonly fullRuntimeReplayExecuted: boolean;
+}
+export interface DeterministicStructuredSessionInputFixtureResult {
+    readonly checksum: string;
+    readonly replayVerified: boolean;
+    readonly predictedFallbackPreservedData: boolean;
+    readonly structuredInputs: number;
+    readonly rejectedNondeterministicPayload: boolean;
+    readonly rejectedSchemaPayloads: number;
+    readonly axisTotal: number;
+    readonly fireTotal: number;
+}
+export interface DeterministicSessionAuthorityFixtureResult {
+    readonly checksum: string;
+    readonly players: number;
+    readonly frames: number;
+    readonly authorityFrame: number;
+    readonly predictedFrame: number;
+    readonly convergence: boolean;
+    readonly replayVerified: boolean;
+    readonly predictedInputs: number;
+    readonly confirmedInputs: number;
+    readonly replacementInputs: number;
+    readonly predictedCommands: number;
+    readonly confirmedCommands: number;
+    readonly reconnects: number;
+    readonly lateJoins: number;
+    readonly spectators: number;
+    readonly rejectedMessages: number;
+    readonly correctionApplied: boolean;
+    readonly lateJoinReconstructed: boolean;
+    readonly spectatorReconstructed: boolean;
+    readonly inputDelayP95: number;
+    readonly rollbackDepthP95: number;
+}
+export interface DeterministicSessionLifecycleProtocolFixtureResult {
+    readonly checksum: string;
+    readonly startRequests: number;
+    readonly simulationStarts: number;
+    readonly spectatorJoinsAccepted: number;
+    readonly addPlayerAccepted: number;
+    readonly addPlayerFailed: number;
+    readonly duplicateAddRejected: number;
+    readonly spectatorInputRejected: number;
+    readonly spectatorCommandRejected: number;
+    readonly sameActorReconnectAccepted: number;
+    readonly differentActorReconnectRejected: number;
+    readonly expiredReconnectRejected: number;
+    readonly removePlayerAccepted: number;
+    readonly replayVerified: boolean;
+    readonly verifiedFrame: number;
+    readonly finalChecksum: string;
+}
+export declare function createDeterministicSessionCore(options: DeterministicSessionOptions): DeterministicSessionCore;
+export declare function createDeterministicSessionReplayBundle(bundle: Omit<DeterministicSessionReplayBundle, 'schemaVersion' | 'checksum'>): DeterministicSessionReplayBundle;
+export declare function verifyDeterministicSessionRuntimeReplay(bundle: DeterministicSessionReplayBundle, options: DeterministicSessionOptions): DeterministicSessionReplayVerification;
+export declare function runDeterministicSessionCoreFixture(players: number, frames: number, seed: number): DeterministicSessionCoreFixtureResult;
+export declare function runDeterministicStructuredSessionInputFixture(): DeterministicStructuredSessionInputFixtureResult;
+export declare function runDeterministicSessionAuthorityFixture(players: number, frames: number, seed: number): DeterministicSessionAuthorityFixtureResult;
+export declare function runDeterministicSessionLifecycleProtocolFixture(): DeterministicSessionLifecycleProtocolFixtureResult;