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

package/dist/sample-lab.js

@@ -0,0 +1,134 @@
+import { createOfflineSession } from './offline-session.js';
+export const labDefaultInput = { dx: 0, dy: 0, action: 0 };
+export const labStep = (state, inputs) => {
+    const positions = state.positions.slice();
+    const actions = state.actions.slice();
+    inputs.forEach((input, slot) => {
+        const baseIndex = slot * 2;
+        positions[baseIndex] = (positions[baseIndex] ?? 0) + input.dx;
+        positions[baseIndex + 1] = (positions[baseIndex + 1] ?? 0) + input.dy;
+        actions[slot] = (actions[slot] ?? 0) + input.action;
+    });
+    return {
+        positions,
+        actions,
+        frame: state.frame + 1,
+        ...(state.payload === undefined ? {} : { payload: state.payload }),
+    };
+};
+export function createLabSession(options) {
+    const initialState = {
+        positions: Array.from({ length: options.players * 2 }, () => 0),
+        actions: Array.from({ length: options.players }, () => 0),
+        frame: 0,
+        ...(options.payloadBytes === undefined ? {} : { payload: 'x'.repeat(options.payloadBytes) }),
+    };
+    return createOfflineSession({
+        tickRate: options.tickRate ?? 30,
+        playerCount: options.players,
+        initialState,
+        step: labStep,
+        defaultInput: labDefaultInput,
+        inputSchemaId: 'lab-input/v1',
+        stateSchemaId: 'lab-state/v1',
+        deterministicVersion: '0.0.0-source',
+        randomSeed: options.seed,
+        snapshotBufferSize: options.snapshotBufferSize,
+        replayRecordingMode: options.replayRecordingMode,
+        onInputFrameRecorded: options.onInputFrameRecorded,
+        onChecksumRecorded: options.onChecksumRecorded,
+        canonicalizeInput: canonicalizeLabInput,
+        hydrateInput: hydrateLabInput,
+    });
+}
+export function canonicalizeLabInput(input) {
+    return [input.dx, input.dy, input.action];
+}
+export function hydrateLabInput(recordedInput) {
+    if (Array.isArray(recordedInput) &&
+        recordedInput.length === 3 &&
+        typeof recordedInput[0] === 'number' &&
+        typeof recordedInput[1] === 'number' &&
+        (recordedInput[2] === 0 || recordedInput[2] === 1)) {
+        return {
+            dx: recordedInput[0],
+            dy: recordedInput[1],
+            action: recordedInput[2],
+        };
+    }
+    throw new Error('Invalid lab replay input');
+}
+export function makeLabInput(random) {
+    return {
+        dx: random.nextInt(-1, 1),
+        dy: random.nextInt(-1, 1),
+        action: random.nextInt(0, 9) === 0 ? 1 : 0,
+    };
+}
+export function applyLabInputs(session, players, random) {
+    const inputs = [];
+    for (let slot = 0; slot < players; slot += 1) {
+        const input = makeLabInput(random);
+        inputs.push(input);
+        session.setInput(slot, input);
+    }
+    return inputs;
+}
+export function packLabInputFrame(inputs) {
+    const writer = new BitWriter(inputs.length * 5);
+    for (const input of inputs) {
+        writer.write(input.dx + 1, 2);
+        writer.write(input.dy + 1, 2);
+        writer.write(input.action, 1);
+    }
+    return writer.toBytes();
+}
+export function unpackLabInputFrame(bytes, players) {
+    const reader = new BitReader(bytes);
+    return Array.from({ length: players }, () => {
+        const dx = reader.read(2) - 1;
+        const dy = reader.read(2) - 1;
+        const action = reader.read(1);
+        if ((dx !== -1 && dx !== 0 && dx !== 1) || (dy !== -1 && dy !== 0 && dy !== 1) || (action !== 0 && action !== 1)) {
+            throw new Error('Invalid packed lab input frame');
+        }
+        return { dx, dy, action };
+    });
+}
+class BitWriter {
+    bytes;
+    bitOffset = 0;
+    constructor(totalBits) {
+        this.bytes = new Uint8Array(Math.ceil(totalBits / 8));
+    }
+    write(value, bits) {
+        for (let bit = 0; bit < bits; bit += 1) {
+            if (((value >> bit) & 1) === 1) {
+                const byteIndex = Math.floor(this.bitOffset / 8);
+                const bitIndex = this.bitOffset % 8;
+                this.bytes[byteIndex] |= 1 << bitIndex;
+            }
+            this.bitOffset += 1;
+        }
+    }
+    toBytes() {
+        return this.bytes;
+    }
+}
+class BitReader {
+    bytes;
+    bitOffset = 0;
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    read(bits) {
+        let value = 0;
+        for (let bit = 0; bit < bits; bit += 1) {
+            const byteIndex = Math.floor(this.bitOffset / 8);
+            const bitIndex = this.bitOffset % 8;
+            value |= ((this.bytes[byteIndex] >> bitIndex) & 1) << bit;
+            this.bitOffset += 1;
+        }
+        return value;
+    }
+}

package/dist/sample-scenes.d.ts

@@ -0,0 +1,86 @@
+export type DeterministicSampleSceneId = 'asteroids' | 'simple-fps' | 'twin-stick' | 'platform-shooter' | 'arena-brawler' | 'vehicle' | 'mini-golf' | 'waiting-room' | 'boat-water' | 'animator';
+export interface DeterministicSampleSceneResult {
+    readonly sampleId: DeterministicSampleSceneId;
+    readonly checksum: string;
+    readonly rollbackChecksum: string;
+    readonly events: number;
+    readonly invariants: Readonly<Record<string, boolean>>;
+    readonly metrics: Readonly<Record<string, number>>;
+}
+export interface DeterministicSampleSceneTraceState {
+    readonly frame: number;
+    readonly stateChecksum: string;
+    readonly x: number;
+    readonly y: number;
+    readonly hp: number;
+    readonly score: number;
+    readonly phase: number;
+}
+export interface DeterministicSampleSceneTrace {
+    readonly sampleId: DeterministicSampleSceneId;
+    readonly frames: number;
+    readonly checksum: string;
+    readonly rollbackChecksum: string;
+    readonly rollbackEquivalent: boolean;
+    readonly mechanics: readonly string[];
+    readonly mechanicCount: number;
+    readonly events: number;
+    readonly representativeStates: readonly DeterministicSampleSceneTraceState[];
+    readonly traceHash: string;
+}
+export interface DeterministicSampleSceneCertificationTrace {
+    readonly schemaVersion: 1;
+    readonly kind: 'deterministic-sample-scene-certification-trace';
+    readonly frames: number;
+    readonly players: number;
+    readonly seed: number;
+    readonly samples: readonly DeterministicSampleSceneTrace[];
+    readonly integrated: {
+        readonly checksum: string;
+        readonly replayChecksum: string;
+        readonly rollbackChecksum: string;
+        readonly replayVerified: boolean;
+        readonly rollbackEquivalent: boolean;
+        readonly replaySnapshots: number;
+        readonly commandsAccepted: number;
+        readonly physicsContacts: number;
+        readonly kccCorrections: number;
+        readonly navReplans: number;
+        readonly botTraceRows: number;
+        readonly animationEvents: number;
+    };
+    readonly sampleCount: number;
+    readonly mechanicCount: number;
+    readonly rollbackEquivalent: boolean;
+    readonly traceHash: string;
+}
+export interface DeterministicIntegratedHeadlessSceneResult {
+    readonly checksum: string;
+    readonly replayChecksum: string;
+    readonly rollbackChecksum: string;
+    readonly replayVerified: boolean;
+    readonly rollbackEquivalent: boolean;
+    readonly metrics: {
+        readonly frames: number;
+        readonly replayFrames: number;
+        readonly replayCapped: boolean;
+        readonly players: number;
+        readonly commandsAccepted: number;
+        readonly sameFrameCommandsAccepted: number;
+        readonly physicsContacts: number;
+        readonly physicsQueries: number;
+        readonly kccCorrections: number;
+        readonly navReplans: number;
+        readonly botTraceRows: number;
+        readonly animationEvents: number;
+        readonly replaySnapshots: number;
+        readonly debugEvents: number;
+        readonly configHashCovered: boolean;
+    };
+    readonly invariants: Readonly<Record<string, boolean>>;
+}
+export declare const deterministicSampleSceneIds: readonly DeterministicSampleSceneId[];
+export declare function runDeterministicSampleScene(sampleId: DeterministicSampleSceneId, frames: number, seed: number): DeterministicSampleSceneResult;
+export declare function runAllDeterministicSampleScenes(frames: number, seed: number): readonly DeterministicSampleSceneResult[];
+export declare function createDeterministicSampleSceneCertificationTrace(frames: number, players: number, seed: number): DeterministicSampleSceneCertificationTrace;
+export declare function runDeterministicIntegratedHeadlessScene(frames: number, players: number, seed: number): DeterministicIntegratedHeadlessSceneResult;