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

package/dist/cjs/prediction-culling.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPredictionCullingLab = runPredictionCullingLab;
+const canonical_js_1 = require("./canonical.js");
+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 = (0, canonical_js_1.defaultChecksum)({
+            frame,
+            predictedBySlot,
+            previousChecksum: predictedChecksum,
+        });
+        verifiedObjectSteps += frameState.length;
+        verifiedChecksum = (0, canonical_js_1.defaultChecksum)({
+            frame,
+            objects: frameState,
+            previousChecksum: verifiedChecksum,
+        });
+        completeChecksum = (0, canonical_js_1.defaultChecksum)({
+            frame,
+            player: getPlayerPosition(0, frame, options.seed),
+            objects: frameState,
+            previousChecksum: completeChecksum,
+        });
+    }
+    const resimulatedChecksum = resimulateVerifiedChecksum(frameHistory, restoreFrame);
+    const predictionFilterChecksum = (0, canonical_js_1.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 = (0, canonical_js_1.defaultChecksum)({
+            frame,
+            objects: frameHistory[frame],
+            previousChecksum: checksum,
+        });
+    }
+    return checksum;
+}
+function resimulateVerifiedChecksumPrefix(frameHistory, endFrameExclusive) {
+    let checksum = '';
+    for (let frame = 0; frame < endFrameExclusive; frame += 1) {
+        checksum = (0, canonical_js_1.defaultChecksum)({
+            frame,
+            objects: frameHistory[frame],
+            previousChecksum: checksum,
+        });
+    }
+    return checksum;
+}