@series-inc/rundot-syncplay 5.26.0-beta.2 → 5.26.0-beta.3

package/dist/prediction-culling.js

@@ -1,200 +0,0 @@
-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;
-}