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

package/dist/prediction-culling.d.ts

@@ -0,0 +1,34 @@
+export type PredictionCullingMode = 'off' | 'local-area';
+export interface PredictionCullingOptions {
+    readonly mode: PredictionCullingMode;
+    readonly players: number;
+    readonly objectsPerPlayer: number;
+    readonly frames: number;
+    readonly seed: number;
+    readonly radius: number;
+    readonly includeHiddenThreat?: boolean;
+}
+export interface PredictionCullingResult {
+    readonly mode: PredictionCullingMode;
+    readonly players: number;
+    readonly objects: number;
+    readonly frames: number;
+    readonly seed: number;
+    readonly radius: number;
+    readonly averagePredictedObjects: string;
+    readonly minPredictedObjects: number;
+    readonly maxPredictedObjects: number;
+    readonly visibleCorrections: number;
+    readonly hiddenAuthoritativeInteractions: number;
+    readonly predictedObjectSteps: number;
+    readonly verifiedObjectSteps: number;
+    readonly culledObjectSteps: number;
+    readonly restoreFrame: number;
+    readonly predictedChecksum: string;
+    readonly verifiedChecksum: string;
+    readonly resimulatedChecksum: string;
+    readonly predictionFilterChecksum: string;
+    readonly completeChecksum: string;
+    readonly result: 'pass' | 'fail';
+}
+export declare function runPredictionCullingLab(options: PredictionCullingOptions): PredictionCullingResult;

package/dist/prediction-culling.js

@@ -0,0 +1,200 @@
+import { defaultChecksum } from './canonical.js';
+export function runPredictionCullingLab(options) {
+    validateOptions(options);
+    const objects = createObjects(options);
+    let previousPredicted = new Set();
+    let predictedTotal = 0;
+    let minPredictedObjects = Number.POSITIVE_INFINITY;
+    let maxPredictedObjects = 0;
+    let visibleCorrections = 0;
+    let hiddenAuthoritativeInteractions = 0;
+    let predictedObjectSteps = 0;
+    let verifiedObjectSteps = 0;
+    let predictedChecksum = '';
+    let verifiedChecksum = '';
+    let completeChecksum = '';
+    const filterHistory = [];
+    const frameHistory = [];
+    const restoreFrame = Math.floor(options.frames * 0.6);
+    for (let frame = 0; frame < options.frames; frame += 1) {
+        const predictedBySlot = [];
+        const frameState = [];
+        for (const object of objects) {
+            frameState.push(getObjectFrameState(object, frame, options.seed));
+        }
+        frameHistory.push(frameState);
+        const localPredicted = new Set();
+        for (let slot = 0; slot < options.players; slot += 1) {
+            const player = getPlayerPosition(slot, frame, options.seed);
+            const slotPredicted = [];
+            for (const objectState of frameState) {
+                const object = objects[objectState.id];
+                if (shouldPredictObject(options.mode, player, object, objectState, options.radius)) {
+                    slotPredicted.push(objectState.id);
+                    if (slot === 0) {
+                        localPredicted.add(objectState.id);
+                    }
+                }
+            }
+            predictedObjectSteps += slotPredicted.length;
+            predictedBySlot.push(slotPredicted);
+        }
+        for (const objectState of frameState) {
+            if (objectState.canAffectPlayer && !localPredicted.has(objectState.id)) {
+                hiddenAuthoritativeInteractions += 1;
+            }
+        }
+        for (const objectId of localPredicted) {
+            if (!previousPredicted.has(objectId) && frame > 0) {
+                visibleCorrections += 1;
+            }
+        }
+        previousPredicted = localPredicted;
+        filterHistory.push(predictedBySlot);
+        predictedTotal += localPredicted.size;
+        minPredictedObjects = Math.min(minPredictedObjects, localPredicted.size);
+        maxPredictedObjects = Math.max(maxPredictedObjects, localPredicted.size);
+        predictedChecksum = defaultChecksum({
+            frame,
+            predictedBySlot,
+            previousChecksum: predictedChecksum,
+        });
+        verifiedObjectSteps += frameState.length;
+        verifiedChecksum = defaultChecksum({
+            frame,
+            objects: frameState,
+            previousChecksum: verifiedChecksum,
+        });
+        completeChecksum = defaultChecksum({
+            frame,
+            player: getPlayerPosition(0, frame, options.seed),
+            objects: frameState,
+            previousChecksum: completeChecksum,
+        });
+    }
+    const resimulatedChecksum = resimulateVerifiedChecksum(frameHistory, restoreFrame);
+    const predictionFilterChecksum = defaultChecksum(filterHistory);
+    const culledObjectSteps = options.mode === 'off' ? 0 : verifiedObjectSteps * options.players - predictedObjectSteps;
+    return {
+        mode: options.mode,
+        players: options.players,
+        objects: objects.length,
+        frames: options.frames,
+        seed: options.seed,
+        radius: options.radius,
+        averagePredictedObjects: (predictedTotal / options.frames).toFixed(2),
+        minPredictedObjects,
+        maxPredictedObjects,
+        visibleCorrections,
+        hiddenAuthoritativeInteractions,
+        predictedObjectSteps,
+        verifiedObjectSteps,
+        culledObjectSteps,
+        restoreFrame,
+        predictedChecksum,
+        verifiedChecksum,
+        resimulatedChecksum,
+        predictionFilterChecksum,
+        completeChecksum,
+        result: hiddenAuthoritativeInteractions === 0 && verifiedChecksum === resimulatedChecksum ? 'pass' : 'fail',
+    };
+}
+function createObjects(options) {
+    const objects = [];
+    for (let slot = 0; slot < options.players; slot += 1) {
+        for (let index = 0; index < options.objectsPerPlayer; index += 1) {
+            const id = objects.length;
+            objects.push({
+                id,
+                ownerSlot: slot,
+                offsetX: ((index * 37 + options.seed) % 90) - 45,
+                offsetY: ((index * 53 + options.seed) % 90) - 45,
+                alwaysPredict: index % 17 === 0,
+                canAffectPlayer: index % 17 === 0,
+            });
+        }
+    }
+    if (options.includeHiddenThreat === true) {
+        objects.push({
+            id: objects.length,
+            ownerSlot: Math.max(1, options.players - 1),
+            offsetX: 10_000,
+            offsetY: 10_000,
+            alwaysPredict: false,
+            canAffectPlayer: true,
+        });
+    }
+    return objects;
+}
+function shouldPredictObject(mode, player, object, objectState, radius) {
+    if (mode === 'off') {
+        return true;
+    }
+    if (object.alwaysPredict) {
+        return true;
+    }
+    const dx = objectState.x - player.x;
+    const dy = objectState.y - player.y;
+    return dx * dx + dy * dy <= radius * radius;
+}
+function getPlayerPosition(slot, frame, seed) {
+    return {
+        x: slot * 100 + ((frame * 3 + seed) % 37),
+        y: ((frame * 5 + seed) % 41) - 20,
+    };
+}
+function getObjectFrameState(object, frame, seed) {
+    const owner = getPlayerPosition(object.ownerSlot, frame, seed);
+    return {
+        id: object.id,
+        x: owner.x + object.offsetX + ((frame + object.id) % 7) - 3,
+        y: owner.y + object.offsetY + ((frame * 2 + object.id) % 7) - 3,
+        active: (frame + object.id) % 29 === 0 ? 0 : 1,
+        canAffectPlayer: object.canAffectPlayer,
+    };
+}
+function validateOptions(options) {
+    if (options.mode !== 'off' && options.mode !== 'local-area') {
+        throw new Error('prediction culling mode must be off or local-area');
+    }
+    if (!Number.isInteger(options.players) || options.players < 1 || options.players > 128) {
+        throw new Error('prediction culling players must be between 1 and 128');
+    }
+    if (!Number.isInteger(options.objectsPerPlayer) || options.objectsPerPlayer < 1 || options.objectsPerPlayer > 128) {
+        throw new Error('objectsPerPlayer must be between 1 and 128');
+    }
+    if (!Number.isInteger(options.frames) || options.frames < 1) {
+        throw new Error('prediction culling frames must be at least 1');
+    }
+    if (!Number.isInteger(options.seed)) {
+        throw new Error('prediction culling seed must be an integer');
+    }
+    if (!Number.isInteger(options.radius) || options.radius < 1) {
+        throw new Error('prediction culling radius must be a positive integer');
+    }
+}
+function resimulateVerifiedChecksum(frameHistory, restoreFrame) {
+    let checksum = '';
+    for (let frame = 0; frame < frameHistory.length; frame += 1) {
+        if (frame === restoreFrame) {
+            checksum = resimulateVerifiedChecksumPrefix(frameHistory, frame);
+        }
+        checksum = defaultChecksum({
+            frame,
+            objects: frameHistory[frame],
+            previousChecksum: checksum,
+        });
+    }
+    return checksum;
+}
+function resimulateVerifiedChecksumPrefix(frameHistory, endFrameExclusive) {
+    let checksum = '';
+    for (let frame = 0; frame < endFrameExclusive; frame += 1) {
+        checksum = defaultChecksum({
+            frame,
+            objects: frameHistory[frame],
+            previousChecksum: checksum,
+        });
+    }
+    return checksum;
+}

package/dist/protocol-lab.d.ts

@@ -0,0 +1,115 @@
+import type { DeterministicEventRecord } from './events.js';
+export type ProtocolRollbackGame = 'lab' | 'counter-duel' | 'moderate-state' | 'command-bursts';
+export type ProtocolPredictionPolicy = 'repeat-last' | 'neutral';
+export interface ProtocolRollbackLabOptions {
+    readonly game?: ProtocolRollbackGame;
+    readonly players: number;
+    readonly frames: number;
+    readonly seed: number;
+    readonly minDelayFrames: number;
+    readonly maxDelayFrames: number;
+    readonly bundleSizeFrames?: number;
+    readonly inputDelayFrames?: number;
+    readonly adaptiveInputDelay?: boolean;
+    readonly maxAdaptiveInputDelayFrames?: number;
+    readonly duplicatePermille?: number;
+    readonly lossPermille?: number;
+    readonly resendIntervalFrames?: number;
+    readonly maxResendAttempts?: number;
+    readonly disconnectStartFrame?: number;
+    readonly disconnectEndFrame?: number;
+    readonly lateJoinSlot?: number;
+    readonly lateJoinFrame?: number;
+    readonly spectatorSlot?: number;
+    readonly spectatorJoinFrame?: number;
+    readonly latencySkewSlot?: number;
+    readonly latencySkewFrames?: number;
+    readonly botSlots?: readonly number[];
+    readonly desyncFrame?: number;
+    readonly desyncSlot?: number;
+    readonly expectDesync?: boolean;
+    readonly eventTimelineLimit?: number;
+    readonly predictionPolicy?: ProtocolPredictionPolicy;
+}
+export interface ProtocolRollbackLabResult {
+    readonly game: ProtocolRollbackGame;
+    readonly frames: number;
+    readonly players: number;
+    readonly confirmations: number;
+    readonly localInputConfirmations: number;
+    readonly localInputRollbacks: number;
+    readonly bundledInputMessages: number;
+    readonly bundleSizeFrames: number;
+    readonly inputDelayFrames: number;
+    readonly adaptiveInputDelay: boolean;
+    readonly finalInputDelayFrames: number;
+    readonly maxObservedInputDelayFrames: number;
+    readonly inputDelayAdjustments: number;
+    readonly deliveries: number;
+    readonly duplicates: number;
+    readonly lost: number;
+    readonly disconnectDrops: number;
+    readonly canceledRetries: number;
+    readonly absentInputFrames: number;
+    readonly botInputFrames: number;
+    readonly reorders: number;
+    readonly rollbacks: number;
+    readonly maxRollbackDepth: number;
+    readonly deliveryDelaySamples: readonly number[];
+    readonly rollbackDepthSamples: readonly number[];
+    readonly eventTimeline: ProtocolRollbackEventTimeline;
+    readonly commandDeliveries: number;
+    readonly commandDuplicates: number;
+    readonly commandLost: number;
+    readonly commandDisconnectDrops: number;
+    readonly commandReorders: number;
+    readonly commandDeliveryDelaySamples: readonly number[];
+    readonly commandRejected: number;
+    readonly commandRejectionCounts: Readonly<Record<string, number>>;
+    readonly commandDuplicateDrops: number;
+    readonly commandRollbackConverged: boolean;
+    readonly commandRollbackObserved: boolean;
+    readonly commandReplayChecksum: string;
+    readonly commandAuthorityChecksum: string;
+    readonly commandClientChecksum: string;
+    readonly spectatorReconstructions: number;
+    readonly spectatorReconstructionChecksum: string;
+    readonly spectatorInputFrames: number;
+    readonly spectatorCommandRejected: number;
+    readonly lateJoinReconstructions: number;
+    readonly lateJoinReconstructionChecksum: string;
+    readonly staleJoinRejected: boolean;
+    readonly predictionPolicy: ProtocolPredictionPolicy;
+    readonly predictedInputFrames: number;
+    readonly neutralPredictions: number;
+    readonly repeatLastPredictions: number;
+    readonly repeatLastNonDefaultPredictions: number;
+    readonly predictionFallbackChecksum: string;
+    readonly authorityChecksum: string;
+    readonly clientChecksum: string;
+    readonly result: 'pass' | 'desync';
+}
+export interface ProtocolRollbackEventPayload {
+    readonly kind: 'input-prediction';
+    readonly frame: number;
+    readonly slot: number;
+}
+export interface ProtocolRollbackEventTimeline {
+    readonly totalRecords: number;
+    readonly sampledRecords: readonly DeterministicEventRecord<ProtocolRollbackEventPayload>[];
+    readonly truncatedRecords: number;
+    readonly predicted: number;
+    readonly confirmed: number;
+    readonly canceled: number;
+    readonly verifiedOnly: number;
+}
+export declare function runProtocolRollbackLab(options: ProtocolRollbackLabOptions): ProtocolRollbackLabResult;
+export declare function runProtocolLabInternalCoverageProbe(): {
+    readonly eventPredicted: number;
+    readonly eventSampled: number;
+    readonly invalidCommandFrame: number;
+    readonly defaultPowerHealth: number;
+    readonly validationReasons: readonly (string | undefined)[];
+    readonly normalizedCommandIds: readonly string[];
+    readonly sortedComparison: readonly number[];
+};