@rian8337/osu-droid-replay-analyzer 1.4.18-alpha.0 → 2.0.0-alpha.10

package/dist/index.js

@@ -1,20 +1,1866 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./data/CursorData"), exports);
-__exportStar(require("./constants/hitResult"), exports);
-__exportStar(require("./constants/movementType"), exports);
-__exportStar(require("./ReplayAnalyzer"), exports);
-__exportStar(require("./data/ReplayData"), exports);
-__exportStar(require("./data/ReplayObjectData"), exports);
-__exportStar(require("./analysis/ThreeFingerChecker"), exports);
-//# sourceMappingURL=index.js.map
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var osuBase = require('@rian8337/osu-base');
+var osuDifficultyCalculator = require('@rian8337/osu-difficulty-calculator');
+var osuRebalanceDifficultyCalculator = require('@rian8337/osu-rebalance-difficulty-calculator');
+var unzipper = require('unzipper');
+var javaDeserialization = require('java-deserialization');
+var stream = require('stream');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var javaDeserialization__namespace = /*#__PURE__*/_interopNamespace(javaDeserialization);
+
+/**
+ * Represents a cursor's occurrence.
+ */
+class CursorOccurrence {
+    /**
+     * The time of this occurrence.
+     */
+    time;
+    /**
+     * The position of the occurrence.
+     */
+    position;
+    /**
+     * The movement ID of the occurrence.
+     */
+    id;
+    constructor(time, x, y, id) {
+        this.time = time;
+        this.position = new osuBase.Vector2(x, y);
+        this.id = id;
+    }
+}
+
+/**
+ * Represents a cursor instance in an osu!droid replay.
+ *
+ * Stores cursor movement data in the form of `CursorOccurrence`s.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+class CursorData {
+    /**
+     * The occurrences of this cursor instance.
+     */
+    occurrences = [];
+    constructor(values) {
+        for (let i = 0; i < values.size; ++i) {
+            this.occurrences.push(new CursorOccurrence(values.time[i], values.x[i], values.y[i], values.id[i]));
+        }
+    }
+}
+
+/**
+ * The result of a hit in an osu!droid replay.
+ */
+exports.hitResult = void 0;
+(function (hitResult) {
+    /**
+     * Miss (0).
+     */
+    hitResult[hitResult["RESULT_0"] = 1] = "RESULT_0";
+    /**
+     * Meh (50).
+     */
+    hitResult[hitResult["RESULT_50"] = 2] = "RESULT_50";
+    /**
+     * Great (100).
+     */
+    hitResult[hitResult["RESULT_100"] = 3] = "RESULT_100";
+    /**
+     * Good (300).
+     */
+    hitResult[hitResult["RESULT_300"] = 4] = "RESULT_300";
+})(exports.hitResult || (exports.hitResult = {}));
+
+/**
+ * Movement type of a cursor in an osu!droid replay.
+ */
+exports.movementType = void 0;
+(function (movementType) {
+    movementType[movementType["DOWN"] = 0] = "DOWN";
+    movementType[movementType["MOVE"] = 1] = "MOVE";
+    movementType[movementType["UP"] = 2] = "UP";
+})(exports.movementType || (exports.movementType = {}));
+
+/**
+ * Represents a replay data in an osu!droid replay.
+ *
+ * Stores generic information about an osu!droid replay such as player name, MD5 hash, time set, etc.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+class ReplayData {
+    replayVersion;
+    folderName;
+    fileName;
+    hash;
+    time;
+    hit300k;
+    hit100k;
+    score;
+    maxCombo;
+    accuracy;
+    isFullCombo;
+    playerName;
+    rawMods;
+    rank;
+    convertedMods;
+    cursorMovement;
+    hitObjectData;
+    speedModification;
+    forcedAR;
+    constructor(values) {
+        this.replayVersion = values.replayVersion;
+        this.folderName = values.folderName;
+        this.fileName = values.fileName;
+        this.hash = values.hash;
+        this.time = new Date(values.time || 0);
+        this.hit300k = values.hit300k || 0;
+        this.hit100k = values.hit100k || 0;
+        this.score = values.score || 0;
+        this.maxCombo = values.maxCombo || 0;
+        this.accuracy = values.accuracy || new osuBase.Accuracy({});
+        this.isFullCombo = values.isFullCombo || false;
+        this.playerName = values.playerName || "";
+        this.rawMods = values.rawMods || "";
+        this.rank = values.rank || "";
+        this.convertedMods = values.convertedMods || [];
+        this.cursorMovement = values.cursorMovement;
+        this.hitObjectData = values.hitObjectData;
+        this.speedModification = values.speedModification || 1;
+        this.forcedAR = values.forcedAR;
+    }
+}
+
+/**
+ * A beatmap section generator that generates beatmap section based on aim/speed strain.
+ */
+class BeatmapSectionGenerator {
+    /**
+     * Generates `BeatmapSection`s for the specified beatmap.
+     *
+     * @param map The beatmap to generate.
+     * @param minSectionObjectCount The maximum delta time allowed between two beatmap sections.
+     * Increasing this number decreases the amount of beatmap sections in general. Note that this value does not account for the speed multiplier of
+     * the play, similar to the way replay object data is stored.
+     * @param maxSectionDeltaTime The minimum object count required to make a beatmap section. Increasing this number decreases the amount of beatmap sections.
+     */
+    static generateSections(map, minSectionObjectCount, maxSectionDeltaTime) {
+        const beatmapSections = [];
+        let firstObjectIndex = 0;
+        for (let i = 0; i < map.objects.length - 1; ++i) {
+            const current = map.objects[i];
+            const next = map.objects[i + 1];
+            const realDeltaTime = next.object.startTime - current.object.endTime;
+            if (realDeltaTime >= maxSectionDeltaTime) {
+                // Ignore sections that don't meet object count requirement.
+                if (i - firstObjectIndex < minSectionObjectCount) {
+                    firstObjectIndex = i + 1;
+                    continue;
+                }
+                beatmapSections.push({
+                    firstObjectIndex,
+                    lastObjectIndex: i,
+                });
+                firstObjectIndex = i + 1;
+            }
+        }
+        // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
+        if (map.objects.length - firstObjectIndex > minSectionObjectCount) {
+            beatmapSections.push({
+                firstObjectIndex,
+                lastObjectIndex: map.objects.length - 1,
+            });
+        }
+        return beatmapSections;
+    }
+}
+
+/**
+ * Represents a section of a beatmap.
+ */
+class BeatmapSection {
+    /**
+     * The index of the first `DifficultyHitObject` of this beatmap section.
+     */
+    firstObjectIndex;
+    /**
+     * The index of the last `DifficultyHitObject` of this beatmap section.
+     */
+    lastObjectIndex;
+    /**
+     * @param firstObjectIndex The index of the first `DifficultyHitObject` of this beatmap section.
+     * @param lastObjectIndex The index of the last `DifficultyHitObject` of this beatmap section.
+     */
+    constructor(firstObjectIndex, lastObjectIndex) {
+        this.firstObjectIndex = firstObjectIndex;
+        this.lastObjectIndex = lastObjectIndex;
+    }
+}
+
+/**
+ * A section of a beatmap with extra information used for detecting three-finger usage.
+ */
+class ThreeFingerBeatmapSection extends BeatmapSection {
+    /**
+     * Whether or not this beatmap section is dragged.
+     */
+    isDragged;
+    /**
+     * The index of the cursor that is dragging this section.
+     */
+    dragFingerIndex;
+    constructor(values) {
+        super(values.firstObjectIndex, values.lastObjectIndex);
+        this.isDragged = values.isDragged;
+        this.dragFingerIndex = values.dragFingerIndex;
+    }
+}
+
+/**
+ * Utility to check whether or not a beatmap is three-fingered.
+ */
+class ThreeFingerChecker {
+    /**
+     * The beatmap to analyze.
+     */
+    map;
+    /**
+     * The data of the replay.
+     */
+    data;
+    /**
+     * The strain threshold to start detecting for 3-fingered section.
+     *
+     * Increasing this number will result in less sections being flagged.
+     */
+    static strainThreshold = 175;
+    /**
+     * The distance threshold between cursors to assume that two cursors are
+     * actually pressed with 1 finger in osu!pixels.
+     *
+     * This is used to prevent cases where a player would lift their finger
+     * too fast to the point where the 4th cursor instance or beyond is recorded
+     * as 1st, 2nd, or 3rd cursor instance.
+     */
+    cursorDistancingDistanceThreshold = 60;
+    /**
+     * The threshold for the amount of cursors that are assumed to be pressed
+     * by a single finger.
+     */
+    cursorDistancingCountThreshold = 10;
+    /**
+     * The threshold for the time difference of cursors that are assumed to be pressed
+     * by a single finger, in milliseconds.
+     */
+    cursorDistancingTimeThreshold = 1000;
+    /**
+     * The amount of notes that has a tap strain exceeding `strainThreshold`.
+     */
+    strainNoteCount;
+    /**
+     * The ratio threshold between non-3 finger cursors and 3-finger cursors.
+     *
+     * Increasing this number will increase detection accuracy, however
+     * it also increases the chance of falsely flagged plays.
+     */
+    threeFingerRatioThreshold = 0.01;
+    /**
+     * The maximum delta time allowed between two beatmap sections.
+     *
+     * Increasing this number decreases the amount of beatmap sections in general.
+     *
+     * Note that this value does not account for the speed multiplier of
+     * the play, similar to the way replay object data is stored.
+     */
+    maxSectionDeltaTime = 2000;
+    /**
+     * The minimum object count required to make a beatmap section.
+     *
+     * Increasing this number decreases the amount of beatmap sections.
+     */
+    minSectionObjectCount = 5;
+    /**
+     * The sections of the beatmap that was cut based on `maxSectionDeltaTime` and `minSectionObjectCount`.
+     */
+    beatmapSections = [];
+    /**
+     * This threshold is used to filter out accidental taps.
+     *
+     * Increasing this number makes the filtration more sensitive, however it
+     * will also increase the chance of 3-fingered plays getting out from
+     * being flagged.
+     */
+    accidentalTapThreshold = 400;
+    /**
+     * The hit window of this beatmap. Keep in mind that speed-changing mods do not change hit window length in game logic.
+     */
+    hitWindow;
+    /**
+     * A reprocessed break points to match right on object time.
+     *
+     * This is used to increase detection accuracy since break points do not start right at the
+     * start of the hitobject before it and do not end right at the first hitobject after it.
+     */
+    breakPointAccurateTimes = [];
+    /**
+     * A cursor data array that only contains `movementType.DOWN` movement ID occurrences.
+     */
+    downCursorInstances = [];
+    /**
+     * Nerf factors from all sections that were three-fingered.
+     */
+    nerfFactors = [];
+    /**
+     * @param map The beatmap to analyze.
+     * @param data The data of the replay.
+     */
+    constructor(map, data) {
+        this.map = map;
+        this.data = data;
+        const stats = new osuBase.MapStats({
+            od: this.map.map.difficulty.od,
+            mods: this.map.mods.filter((m) => !osuBase.ModUtil.speedChangingMods
+                .map((v) => v.droidString)
+                .includes(m.droidString)),
+        }).calculate();
+        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
+        const strainNotes = map.objects.filter((v) => v.originalTapStrain >= ThreeFingerChecker.strainThreshold);
+        this.strainNoteCount = strainNotes.length;
+    }
+    /**
+     * Checks whether a beatmap is eligible to be detected for 3-finger.
+     */
+    static isEligibleToDetect(map) {
+        return map.objects.some((v) => v.originalTapStrain >= this.strainThreshold);
+    }
+    /**
+     * Checks if the given beatmap is 3-fingered and also returns the final penalty.
+     *
+     * The beatmap will be separated into sections and each section will be determined
+     * whether or not it is dragged.
+     *
+     * After that, each section will be assigned a nerf factor based on whether or not
+     * the section is 3-fingered. These nerf factors will be summed up into a final
+     * nerf factor, taking beatmap difficulty into account.
+     */
+    check() {
+        if (this.strainNoteCount === 0) {
+            return { is3Finger: false, penalty: 1 };
+        }
+        this.getAccurateBreakPoints();
+        this.filterCursorInstances();
+        if (this.downCursorInstances.filter((v) => v.occurrences.length > 0)
+            .length <= 3) {
+            return { is3Finger: false, penalty: 1 };
+        }
+        this.getBeatmapSections();
+        this.detectDragPlay();
+        this.getDetailedBeatmapSections();
+        this.preventAccidentalTaps();
+        if (this.downCursorInstances.filter((v) => v.occurrences.length > 0)
+            .length <= 3) {
+            return { is3Finger: false, penalty: 1 };
+        }
+        this.calculateNerfFactors();
+        const finalPenalty = this.calculateFinalPenalty();
+        return { is3Finger: finalPenalty > 1, penalty: finalPenalty };
+    }
+    /**
+     * Generates a new set of "accurate break points".
+     *
+     * This is done to increase detection accuracy since break points do not start right at the
+     * start of the hitobject before it and do not end right at the first hitobject after it.
+     */
+    getAccurateBreakPoints() {
+        const objects = this.map.objects;
+        const objectData = this.data.hitObjectData;
+        const isPrecise = this.map.mods.some((m) => m instanceof osuBase.ModPrecise);
+        for (const breakPoint of this.map.map.events.breaks) {
+            const beforeIndex = osuBase.MathUtils.clamp(objects.findIndex((o) => o.object.endTime >= breakPoint.startTime) - 1, 0, objects.length - 2);
+            let timeBefore = objects[beforeIndex].object.endTime;
+            // For sliders and spinners, automatically set hit window length to be as lenient as possible.
+            let beforeIndexHitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
+            switch (objectData[beforeIndex].result) {
+                case exports.hitResult.RESULT_300:
+                    beforeIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    beforeIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+                default:
+                    beforeIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor50(isPrecise);
+            }
+            timeBefore += beforeIndexHitWindowLength;
+            const afterIndex = beforeIndex + 1;
+            let timeAfter = objects[afterIndex].object.startTime;
+            // For sliders and spinners, automatically set hit window length to be as lenient as possible.
+            let afterIndexHitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
+            switch (objectData[afterIndex].result) {
+                case exports.hitResult.RESULT_300:
+                    afterIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    afterIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+                default:
+                    afterIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor50(isPrecise);
+            }
+            timeAfter += afterIndexHitWindowLength;
+            this.breakPointAccurateTimes.push({
+                startTime: timeBefore,
+                endTime: timeAfter,
+            });
+        }
+    }
+    /**
+     * Filters the original cursor instances, returning only those with `movementType.DOWN` movement ID.
+     *
+     * This also filters cursors that are in break period or happen before start/after end of the beatmap.
+     */
+    filterCursorInstances() {
+        const objects = this.map.objects;
+        const objectData = this.data.hitObjectData;
+        const firstObjectResult = objectData[0].result;
+        const lastObjectResult = objectData.at(-1).result;
+        const isPrecise = this.map.mods.some((m) => m instanceof osuBase.ModPrecise);
+        // For sliders, automatically set hit window length to be as lenient as possible.
+        let firstObjectHitWindow = this.hitWindow.hitWindowFor50(isPrecise);
+        if (objects[0].object instanceof osuBase.Circle) {
+            switch (firstObjectResult) {
+                case exports.hitResult.RESULT_300:
+                    firstObjectHitWindow =
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    firstObjectHitWindow =
+                        this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+                default:
+                    firstObjectHitWindow =
+                        this.hitWindow.hitWindowFor50(isPrecise);
+            }
+        }
+        // For sliders, automatically set hit window length to be as lenient as possible.
+        let lastObjectHitWindow = this.hitWindow.hitWindowFor50(isPrecise);
+        if (objects.at(-1).object instanceof osuBase.Circle) {
+            switch (lastObjectResult) {
+                case exports.hitResult.RESULT_300:
+                    lastObjectHitWindow =
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    lastObjectHitWindow =
+                        this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+                default:
+                    lastObjectHitWindow =
+                        this.hitWindow.hitWindowFor50(isPrecise);
+            }
+        }
+        // These hit time uses hit window length as threshold.
+        // This is because cursors aren't recorded exactly at hit time,
+        // probably due to the game's behavior.
+        const firstObjectHitTime = objects[0].object.startTime - firstObjectHitWindow;
+        const lastObjectHitTime = objects.at(-1).object.startTime + lastObjectHitWindow;
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const cursorInstance = this.data.cursorMovement[i];
+            const newCursorData = new CursorData({
+                size: 0,
+                time: [],
+                x: [],
+                y: [],
+                id: [],
+            });
+            for (let j = 0; j < cursorInstance.occurrences.length; ++j) {
+                if (cursorInstance.occurrences[j].id !== exports.movementType.DOWN) {
+                    continue;
+                }
+                const time = cursorInstance.occurrences[j].time;
+                if (time < firstObjectHitTime || time > lastObjectHitTime) {
+                    continue;
+                }
+                if (this.breakPointAccurateTimes.some((v) => time >= v.startTime && time <= v.endTime)) {
+                    continue;
+                }
+                newCursorData.occurrences.push(new CursorOccurrence(time, cursorInstance.occurrences[j].position.x, cursorInstance.occurrences[j].position.y, cursorInstance.occurrences[j].id));
+            }
+            this.downCursorInstances.push(newCursorData);
+        }
+    }
+    /**
+     * Divides the beatmap into sections, which will be used to
+     * detect dragged sections and improve detection speed.
+     */
+    getBeatmapSections() {
+        const beatmapSections = BeatmapSectionGenerator.generateSections(this.map, this.minSectionObjectCount, this.maxSectionDeltaTime);
+        for (const beatmapSection of beatmapSections) {
+            this.beatmapSections.push(new ThreeFingerBeatmapSection({
+                firstObjectIndex: beatmapSection.firstObjectIndex,
+                lastObjectIndex: beatmapSection.lastObjectIndex,
+                isDragged: false,
+                dragFingerIndex: -1,
+            }));
+        }
+    }
+    /**
+     * Checks whether or not each beatmap sections is dragged.
+     */
+    detectDragPlay() {
+        for (let i = 0; i < this.beatmapSections.length; ++i) {
+            const dragIndex = this.checkDrag(this.beatmapSections[i]);
+            this.beatmapSections[i].dragFingerIndex = dragIndex;
+            this.beatmapSections[i].isDragged = dragIndex !== -1;
+        }
+    }
+    /**
+     * Checks if a section is dragged and returns the index of the drag finger.
+     *
+     * If the section is not dragged, -1 will be returned.
+     *
+     * @param section The section to check.
+     */
+    checkDrag(section) {
+        const objects = this.map.objects;
+        const objectData = this.data.hitObjectData;
+        const isPrecise = this.map.mods.some((m) => m instanceof osuBase.ModPrecise);
+        const firstObject = objects[section.firstObjectIndex];
+        const lastObject = objects[section.lastObjectIndex];
+        let firstObjectMinHitTime = firstObject.object.startTime;
+        if (firstObject.object instanceof osuBase.Circle) {
+            switch (objectData[section.firstObjectIndex].result) {
+                case exports.hitResult.RESULT_300:
+                    firstObjectMinHitTime -=
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    firstObjectMinHitTime -=
+                        this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+                default:
+                    firstObjectMinHitTime -=
+                        this.hitWindow.hitWindowFor50(isPrecise);
+            }
+        }
+        else {
+            firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(isPrecise);
+        }
+        let lastObjectMaxHitTime = lastObject.object.startTime;
+        if (lastObject.object instanceof osuBase.Circle) {
+            switch (objectData[section.lastObjectIndex].result) {
+                case exports.hitResult.RESULT_300:
+                    lastObjectMaxHitTime +=
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    lastObjectMaxHitTime +=
+                        this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+                default:
+                    lastObjectMaxHitTime +=
+                        this.hitWindow.hitWindowFor50(isPrecise);
+            }
+        }
+        else {
+            lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(isPrecise);
+        }
+        // Since there may be more than 1 cursor instance index,
+        // we check which cursor instance follows hitobjects all over.
+        const cursorIndexes = [];
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const c = this.data.cursorMovement[i];
+            if (c.occurrences.length === 0) {
+                continue;
+            }
+            // Do not include cursors that don't have an occurence in this section
+            // this speeds up checking process.
+            if (c.occurrences.filter((v) => v.time >= firstObjectMinHitTime &&
+                v.time <= lastObjectMaxHitTime).length === 0) {
+                continue;
+            }
+            // If this cursor instance doesn't move, it's not the cursor instance we want.
+            if (c.occurrences.filter((v) => v.id === exports.movementType.MOVE)
+                .length === 0) {
+                continue;
+            }
+            cursorIndexes.push(i);
+        }
+        return this.findDragIndex(objects.slice(section.firstObjectIndex, section.lastObjectIndex + 1), objectData.slice(section.firstObjectIndex, section.lastObjectIndex + 1), cursorIndexes);
+    }
+    /**
+     * Finds the drag index of the section.
+     *
+     * @param sectionObjects The objects in the section.
+     * @param sectionReplayObjectData The hitobject data of all objects in the section.
+     * @param cursorIndexes The indexes of the cursor instance that has at least an occurrence in the section.
+     */
+    findDragIndex(sectionObjects, sectionReplayObjectData, cursorIndexes) {
+        let objectIndex = sectionObjects.findIndex((v, i) => !(v.object instanceof osuBase.Spinner) &&
+            sectionReplayObjectData[i].result !== exports.hitResult.RESULT_0);
+        if (objectIndex === -1) {
+            return -1;
+        }
+        while (cursorIndexes.length > 0) {
+            if (objectIndex === sectionObjects.length) {
+                break;
+            }
+            const o = sectionObjects[objectIndex];
+            const s = sectionReplayObjectData[objectIndex];
+            ++objectIndex;
+            if (s.result === exports.hitResult.RESULT_0) {
+                continue;
+            }
+            // Get the cursor instance that is closest to the object's hit time.
+            for (let j = 0; j < cursorIndexes.length; ++j) {
+                const c = this.data.cursorMovement[cursorIndexes[j]];
+                // Cursor instances aren't always recorded at all times,
+                // therefore the game emulates the movement between
+                // movementType.MOVE cursors.
+                const hitTime = o.object.startTime + s.accuracy;
+                const nextHitIndex = c.occurrences.findIndex((v) => v.time >= hitTime);
+                const hitIndex = nextHitIndex - 1;
+                if (hitIndex <= -1) {
+                    cursorIndexes[j] = -1;
+                    continue;
+                }
+                if (c.occurrences[hitIndex].id === exports.movementType.UP) {
+                    cursorIndexes[j] = -1;
+                    continue;
+                }
+                const cursorPosition = new osuBase.Vector2(c.occurrences[hitIndex].position.x, c.occurrences[hitIndex].position.y);
+                let isInObject = false;
+                if (c.occurrences[nextHitIndex].id === exports.movementType.MOVE ||
+                    c.occurrences[hitIndex].id === exports.movementType.MOVE) {
+                    // Try to interpolate movement between two movementType.MOVE cursor every 1ms.
+                    // This minimizes rounding error.
+                    for (let mSecPassed = c.occurrences[hitIndex].time; mSecPassed <= c.occurrences[nextHitIndex].time; ++mSecPassed) {
+                        const t = (mSecPassed - c.occurrences[nextHitIndex].time) /
+                            (c.occurrences[hitIndex].time -
+                                c.occurrences[nextHitIndex].time);
+                        cursorPosition.x = osuBase.Interpolation.lerp(c.occurrences[hitIndex].position.x, c.occurrences[nextHitIndex].position.x, t);
+                        cursorPosition.y = osuBase.Interpolation.lerp(c.occurrences[hitIndex].position.y, c.occurrences[nextHitIndex].position.y, t);
+                        if (o.object.stackedPosition.getDistance(cursorPosition) <= o.object.radius) {
+                            isInObject = true;
+                            break;
+                        }
+                    }
+                }
+                else {
+                    isInObject =
+                        o.object.stackedPosition.getDistance(cursorPosition) <=
+                            o.object.radius;
+                }
+                if (!isInObject) {
+                    cursorIndexes[j] = -1;
+                }
+            }
+            cursorIndexes = cursorIndexes.filter((v) => v !== -1);
+        }
+        return cursorIndexes.shift() ?? -1;
+    }
+    /**
+     * Redivides the beatmap into sections.
+     *
+     * The result will be used to detect for three-fingered
+     * sections.
+     */
+    getDetailedBeatmapSections() {
+        const objects = this.map.objects;
+        const newBeatmapSections = [];
+        for (const beatmapSection of this.beatmapSections) {
+            let inSpeedSection = false;
+            let newFirstObjectIndex = beatmapSection.firstObjectIndex;
+            for (let i = beatmapSection.firstObjectIndex; i <= beatmapSection.lastObjectIndex; ++i) {
+                if (!inSpeedSection &&
+                    objects[i].originalTapStrain >=
+                        ThreeFingerChecker.strainThreshold) {
+                    inSpeedSection = true;
+                    newFirstObjectIndex = i;
+                    continue;
+                }
+                if (inSpeedSection &&
+                    objects[i].originalTapStrain <
+                        ThreeFingerChecker.strainThreshold) {
+                    inSpeedSection = false;
+                    newBeatmapSections.push({
+                        firstObjectIndex: newFirstObjectIndex,
+                        lastObjectIndex: i,
+                        isDragged: beatmapSection.isDragged,
+                        dragFingerIndex: beatmapSection.dragFingerIndex,
+                    });
+                }
+            }
+            // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
+            if (inSpeedSection) {
+                newBeatmapSections.push({
+                    firstObjectIndex: newFirstObjectIndex,
+                    lastObjectIndex: beatmapSection.lastObjectIndex,
+                    isDragged: beatmapSection.isDragged,
+                    dragFingerIndex: beatmapSection.dragFingerIndex,
+                });
+            }
+        }
+        this.beatmapSections.length = 0;
+        this.beatmapSections.push(...newBeatmapSections);
+    }
+    /**
+     * Attempts to prevent accidental taps from being flagged.
+     *
+     * This detection will filter cursors that don't hit
+     * any object in beatmap sections, thus eliminating any
+     * unnecessary taps.
+     */
+    preventAccidentalTaps() {
+        let filledCursorAmount = this.downCursorInstances.filter((v) => v.occurrences.length > 0).length;
+        if (filledCursorAmount <= 3) {
+            return;
+        }
+        const objects = this.map.objects;
+        const totalCursorAmount = this.downCursorInstances.reduce((acc, value) => acc + value.occurrences.length, 0);
+        for (let i = 0; i < this.downCursorInstances.length; ++i) {
+            if (filledCursorAmount <= 3) {
+                break;
+            }
+            const cursorInstance = this.downCursorInstances[i];
+            // Use an estimation for accidental tap threshold.
+            if (cursorInstance.occurrences.length <=
+                Math.ceil(objects.length / this.accidentalTapThreshold) &&
+                cursorInstance.occurrences.length / totalCursorAmount <
+                    this.threeFingerRatioThreshold * 2) {
+                --filledCursorAmount;
+                cursorInstance.occurrences.length = 0;
+            }
+            this.downCursorInstances[i] = cursorInstance;
+        }
+    }
+    /**
+     * Creates nerf factors by scanning through objects.
+     *
+     * This check will ignore all objects with speed strain below `strainThreshold`.
+     */
+    calculateNerfFactors() {
+        const objects = this.map.objects;
+        const objectData = this.data.hitObjectData;
+        const isPrecise = this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise);
+        // We only filter cursor instances that are above the strain threshold.
+        // This minimalizes the amount of cursor instances to analyze.
+        for (const beatmapSection of this.beatmapSections) {
+            const dragIndex = beatmapSection.dragFingerIndex;
+            const startTime = objects[beatmapSection.firstObjectIndex].object.startTime +
+                (objectData[beatmapSection.firstObjectIndex].result !==
+                    exports.hitResult.RESULT_0
+                    ? objectData[beatmapSection.firstObjectIndex].accuracy
+                    : -this.hitWindow.hitWindowFor50(isPrecise));
+            const endTime = objects[beatmapSection.lastObjectIndex].object.endTime +
+                (objectData[beatmapSection.lastObjectIndex].result !==
+                    exports.hitResult.RESULT_0
+                    ? objectData[beatmapSection.lastObjectIndex].accuracy
+                    : this.hitWindow.hitWindowFor50(isPrecise));
+            // Filter cursor instances during section.
+            this.downCursorInstances.forEach((c) => {
+                const i = c.occurrences.findIndex((t) => t.time >= startTime);
+                if (i !== -1) {
+                    c.occurrences = c.occurrences.slice(0, i);
+                }
+            });
+            const cursorAmounts = [];
+            const cursorVectorTimes = [];
+            for (let i = 0; i < this.downCursorInstances.length; ++i) {
+                // Do not include drag cursor instance.
+                if (i === dragIndex) {
+                    continue;
+                }
+                const cursorData = this.downCursorInstances[i];
+                let amount = 0;
+                for (let j = 0; j < cursorData.occurrences.length; ++j) {
+                    if (cursorData.occurrences[j].time >= startTime &&
+                        cursorData.occurrences[j].time <= endTime) {
+                        ++amount;
+                        cursorVectorTimes.push({
+                            vector: new osuBase.Vector2(cursorData.occurrences[j].position.x, cursorData.occurrences[j].position.y),
+                            time: cursorData.occurrences[j].time,
+                        });
+                    }
+                }
+                cursorAmounts.push(amount);
+            }
+            // This index will be used to detect if a section is 3-fingered.
+            // If the section is dragged, the dragged instance will be ignored,
+            // hence why the index is 1 less than nondragged section.
+            const fingerSplitIndex = dragIndex !== -1 ? 2 : 3;
+            // Divide >=4th (3rd for drag) cursor instances with 1st + 2nd (+ 3rd for nondrag)
+            // to check if the section is 3-fingered.
+            const threeFingerRatio = cursorAmounts
+                .slice(fingerSplitIndex)
+                .reduce((acc, value) => acc + value, 0) /
+                cursorAmounts
+                    .slice(0, fingerSplitIndex)
+                    .reduce((acc, value) => acc + value, 0);
+            const similarPresses = [];
+            for (const cursorVectorTime of cursorVectorTimes) {
+                const pressIndex = similarPresses.findIndex((v) => v.vector.getDistance(cursorVectorTime.vector) <=
+                    this.cursorDistancingDistanceThreshold);
+                if (pressIndex !== -1) {
+                    if (cursorVectorTime.time -
+                        similarPresses[pressIndex].lastTime >=
+                        this.cursorDistancingTimeThreshold) {
+                        similarPresses.splice(pressIndex, 1);
+                        similarPresses.push({
+                            vector: cursorVectorTime.vector,
+                            count: 1,
+                            lastTime: cursorVectorTime.time,
+                        });
+                        continue;
+                    }
+                    similarPresses[pressIndex].vector = cursorVectorTime.vector;
+                    similarPresses[pressIndex].lastTime = cursorVectorTime.time;
+                    ++similarPresses[pressIndex].count;
+                }
+                else {
+                    similarPresses.push({
+                        vector: cursorVectorTime.vector,
+                        count: 1,
+                        lastTime: cursorVectorTime.time,
+                    });
+                }
+            }
+            // Sort by highest count; assume the order is 3rd, 4th, 5th, ... finger
+            const validPresses = similarPresses
+                .filter((v) => v.count >= this.cursorDistancingCountThreshold)
+                .sort((a, b) => {
+                return b.count - a.count;
+            })
+                .slice(2);
+            // Ignore cursor presses that are only 1 for now since they are very likely to be accidental
+            if ((threeFingerRatio > this.threeFingerRatioThreshold &&
+                cursorAmounts.filter((v) => v > 1).length > 3) ||
+                validPresses.length > 0) {
+                // Strain factor
+                const objectCount = beatmapSection.lastObjectIndex -
+                    beatmapSection.firstObjectIndex +
+                    1;
+                const strainFactor = Math.pow(objects
+                    .slice(beatmapSection.firstObjectIndex, beatmapSection.lastObjectIndex)
+                    .reduce((acc, value) => acc +
+                    value.originalTapStrain /
+                        ThreeFingerChecker.strainThreshold, 0), 0.75);
+                // We can ignore the first 3 (2 for drag) filled cursor instances
+                // since they are guaranteed not 3 finger.
+                const threeFingerCursorAmounts = cursorAmounts
+                    .slice(fingerSplitIndex)
+                    .filter((amount) => amount > 0);
+                // Finger factor applies more penalty if more fingers were used.
+                const fingerFactor = threeFingerRatio > this.threeFingerRatioThreshold
+                    ? threeFingerCursorAmounts.reduce((acc, value, index) => acc +
+                        Math.pow(((index + 1) * value * objectCount) /
+                            this.strainNoteCount, 0.8), 1)
+                    : Math.pow(validPresses.reduce((acc, value, index) => acc +
+                        Math.pow(((index + 1) *
+                            (value.count /
+                                (this
+                                    .cursorDistancingCountThreshold *
+                                    2)) *
+                            objectCount) /
+                            this.strainNoteCount, 0.2), 1), 0.2);
+                // Length factor applies more penalty if there are more 3-fingered object.
+                const lengthFactor = 1 + Math.pow(objectCount / this.strainNoteCount, 1.2);
+                this.nerfFactors.push({
+                    strainFactor: Math.max(1, strainFactor),
+                    fingerFactor,
+                    lengthFactor,
+                });
+            }
+        }
+    }
+    /**
+     * Calculates the final penalty.
+     */
+    calculateFinalPenalty() {
+        return (1 +
+            this.nerfFactors.reduce((a, n) => a +
+                0.015 *
+                    Math.pow(n.strainFactor * n.fingerFactor * n.lengthFactor, 1.05), 0));
+    }
+}
+
+/**
+ * Contains information about which cursor index hits a hitobject.
+ */
+class IndexedHitObject {
+    /**
+     * The index of the cursor that hits the hitobject.
+     */
+    cursorIndex;
+    /**
+     * The underlying difficulty hitobject.
+     */
+    object;
+    /**
+     * @param object The underlying difficulty hitobject.
+     * @param cursorIndex The index of the cursor that hits the hitobject.
+     */
+    constructor(object, cursorIndex) {
+        this.object = object;
+        this.cursorIndex = cursorIndex;
+    }
+}
+
+/**
+ * Utility to check whether or not a beatmap is two-handed.
+ */
+class TwoHandChecker {
+    /**
+     * The beatmap that is being analyzed.
+     */
+    map;
+    /**
+     * The data of the replay.
+     */
+    data;
+    /**
+     * The hitobjects of the beatmap that have been assigned with their respective cursor index.
+     */
+    indexedHitObjects = [];
+    /**
+     * The osu!droid hitwindow of the analyzed beatmap.
+     */
+    hitWindow;
+    /**
+     * The minimum count of a cursor index occurrence to be valid.
+     *
+     * This is used to prevent excessive penalty by splitting the beatmap into
+     * those that do not worth any strain.
+     */
+    minCursorIndexCount = 5;
+    /**
+     * The approximated difficulty of the current object such that the object is likely to be 2-handed by a player.
+     *
+     * This scales with an object's angle and speed relative to the previous object.
+     * Acute angles or fast speed will accumulate this number. Conversely, wide angles or slow speed will decay this number.
+     */
+    currentAngleDiffApproxDefault = 10;
+    /**
+     * The threshold at which objects will be started getting considered to be 2-handable.
+     */
+    currentAngleDiffApproxThreshold = 200;
+    /**
+     * @param map The beatmap to analyze.
+     * @param data The data of the replay.
+     */
+    constructor(map, data) {
+        this.map = map;
+        this.data = data;
+        const stats = new osuBase.MapStats({
+            od: this.map.map.difficulty.od,
+            mods: this.map.mods.filter((m) => !osuBase.ModUtil.speedChangingMods
+                .map((v) => v.droidString)
+                .includes(m.droidString)),
+        }).calculate();
+        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
+    }
+    /**
+     * Checks if a beatmap is two-handed.
+     */
+    check() {
+        if (this.data.cursorMovement.filter((v) => v.occurrences.length > 0)
+            .length <= 1) {
+            return false;
+        }
+        this.indexHitObjects();
+        this.applyPenalty();
+        return true;
+    }
+    /**
+     * Converts hitobjects into indexed hit objects.
+     */
+    indexHitObjects() {
+        const hitWindowOffset = this.getHitWindowOffset();
+        const indexes = [];
+        let overallDiffApprox = this.currentAngleDiffApproxDefault;
+        for (let i = 0; i < this.map.objects.length; ++i) {
+            const diff = i > 0 ? this.getSpacingAngleDiffApprox(i) : 1;
+            overallDiffApprox = osuBase.MathUtils.clamp(overallDiffApprox * diff, this.currentAngleDiffApproxDefault, this.currentAngleDiffApproxThreshold + 100);
+            const index = overallDiffApprox >= this.currentAngleDiffApproxThreshold
+                ? this.getCursorIndex(i, hitWindowOffset)
+                : -1;
+            indexes.push(index);
+            this.indexedHitObjects.push(new IndexedHitObject(this.map.objects[i], index));
+        }
+        const indexCounts = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
+        for (const index of indexes) {
+            if (index === -1) {
+                continue;
+            }
+            ++indexCounts[index];
+        }
+        const mainCursorIndex = indexCounts.indexOf(Math.max(...indexCounts));
+        const ignoredCursorIndexes = [];
+        for (let i = 0; i < indexCounts.length; ++i) {
+            if (indexCounts[i] < this.minCursorIndexCount &&
+                i !== mainCursorIndex) {
+                ignoredCursorIndexes.push(i);
+            }
+        }
+        this.indexedHitObjects.forEach((indexedHitObject) => {
+            if (indexedHitObject.cursorIndex === -1 ||
+                ignoredCursorIndexes.includes(indexedHitObject.cursorIndex)) {
+                indexedHitObject.cursorIndex = mainCursorIndex;
+            }
+        });
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            console.log("Index", i, "count:", this.indexedHitObjects.filter((v) => v.cursorIndex === i).length);
+        }
+    }
+    /**
+     * Gets the approximation of an object's difficulty such that the object is likely to be 2-handed.
+     *
+     * @param index The index of the object.
+     */
+    getSpacingAngleDiffApprox(index) {
+        const object = this.map.objects[index];
+        if (object.object instanceof osuBase.Spinner) {
+            return 0.1;
+        }
+        const angleDiff = object.angle !== null
+            ? 0.5 + Math.pow(Math.cos(object.angle / 2), 2)
+            : 1;
+        const speedDiff = object.lazyJumpDistance / Math.max(1, object.deltaTime);
+        // Make decay slower.
+        return Math.max(0.8, angleDiff * speedDiff);
+    }
+    /**
+     * Gets the hit window offset to be applied to `getCursorIndex`.
+     */
+    getHitWindowOffset() {
+        const deltaTimes = [];
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const c = this.data.cursorMovement[i];
+            for (let j = 0; j < c.occurrences.length; ++j) {
+                if (c.occurrences[j].time <
+                    this.map.map.hitObjects.objects[0].startTime -
+                        this.hitWindow.hitWindowFor50()) {
+                    continue;
+                }
+                if (c.occurrences[j].id !== exports.movementType.MOVE) {
+                    continue;
+                }
+                const deltaTime = c.occurrences[j]?.time - c.occurrences[j - 1]?.time || 0;
+                if (deltaTime > 0) {
+                    deltaTimes.push(deltaTime);
+                }
+            }
+        }
+        return Math.min(...deltaTimes);
+    }
+    /**
+     * Gets the cursor index that hits the given object.
+     *
+     * @param index The index of the object to check.
+     * @param hitWindowOffset The offset for hit window to compensate for replay hit inaccuracies.
+     * @returns The cursor index that hits the given object, -1 if the index is not found, the object is a spinner, or the object was missed.
+     */
+    getCursorIndex(index, hitWindowOffset) {
+        const object = this.map.objects[index];
+        const data = this.data.hitObjectData[index];
+        if (object.object instanceof osuBase.Spinner ||
+            data.result === exports.hitResult.RESULT_0) {
+            return -1;
+        }
+        const isPrecise = this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise);
+        // For sliders, automatically set hit window to be as lenient as possible.
+        let hitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
+        if (!(object.object instanceof osuBase.Slider)) {
+            switch (data.result) {
+                case exports.hitResult.RESULT_300:
+                    hitWindowLength = this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    hitWindowLength = this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+            }
+        }
+        const startTime = object.object.startTime;
+        const hitTime = startTime + data.accuracy;
+        const minimumHitTime = startTime - hitWindowLength - hitWindowOffset;
+        const maximumHitTime = startTime + hitWindowLength + hitWindowOffset;
+        const cursorInformations = [];
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const c = this.data.cursorMovement[i];
+            if (c.occurrences.length === 0) {
+                continue;
+            }
+            let hitTimeBeforeIndex = osuBase.MathUtils.clamp(c.occurrences.findIndex((v) => v.time >= minimumHitTime), 0, c.occurrences.length - 2);
+            let hitTimeAfterIndex = c.occurrences.findIndex(
+            // There is a special case for sliders where the time leniency in droid is a lot bigger compared to PC.
+            // To prevent slider end time from ending earlier than hit window leniency, we use the maximum value between both.
+            (v) => v.time >= Math.max(object.object.endTime, maximumHitTime));
+            if (hitTimeAfterIndex === -1) {
+                // Maximum hit time or object end time may be out of bounds for every presses.
+                // We set the index to the latest cursor occurrence if that happens.
+                hitTimeAfterIndex = c.occurrences.length;
+            }
+            --hitTimeAfterIndex;
+            // Sometimes a `movementType.UP` instance occurs at the same time as a `movementType.MOVE`
+            // or a cursor is recorded twice in one time, therefore this check is required.
+            while (c.occurrences[hitTimeBeforeIndex]?.time ===
+                c.occurrences[hitTimeBeforeIndex - 1]?.time &&
+                hitTimeBeforeIndex > 0) {
+                --hitTimeBeforeIndex;
+            }
+            // We track the cursor movement along those indexes.
+            // Current cursor position is in `hitTimeBeforeIndex`.
+            let distance = Number.POSITIVE_INFINITY;
+            let acceptableRadius = object.object.radius;
+            // Sliders have a bigger radius tolerance due to slider ball.
+            if (object.object instanceof osuBase.Slider) {
+                acceptableRadius *= 2.4;
+            }
+            let j = hitTimeBeforeIndex;
+            for (j; j <= hitTimeAfterIndex; ++j) {
+                const occurrence = c.occurrences[j];
+                const nextOccurrence = c.occurrences[j + 1];
+                const cursorPosition = occurrence.position;
+                if (occurrence.time > hitTime + hitWindowOffset) {
+                    // Set distance to minimum just for the last.
+                    if (occurrence.id !== exports.movementType.UP) {
+                        distance = Math.min(distance, object.object.stackedPosition.getDistance(cursorPosition));
+                    }
+                    break;
+                }
+                if (occurrence.id === exports.movementType.UP) {
+                    continue;
+                }
+                distance =
+                    object.object.stackedPosition.getDistance(cursorPosition);
+                if (nextOccurrence &&
+                    nextOccurrence.id === exports.movementType.MOVE &&
+                    occurrence.time !== nextOccurrence.time &&
+                    !occurrence.position.equals(nextOccurrence.position)) {
+                    // If next cursor is a `move` instance and it doesn't go out of time
+                    // range, we interpolate cursor position between two occurrences.
+                    const nextPosition = nextOccurrence.position;
+                    const displacement = nextPosition.subtract(cursorPosition);
+                    for (let mSecPassed = Math.max(minimumHitTime, occurrence.time); mSecPassed <=
+                        Math.min(hitTime + hitWindowOffset, nextOccurrence.time); ++mSecPassed) {
+                        const progress = (mSecPassed - occurrence.time) /
+                            (nextOccurrence.time - occurrence.time);
+                        distance = object.object.stackedPosition.getDistance(cursorPosition.add(displacement.scale(progress)));
+                    }
+                }
+            }
+            if (distance > acceptableRadius) {
+                continue;
+            }
+            // The case for a one-handed object is that there will be a slight movement in the cursor towards
+            // the next object in fast patterns. We should not be worried about slow patterns as they will only
+            // make a minimal difference and the difficulty approximation we did earlier should filter them out.
+            // In order to verify if the player does that, we check if the movement towards the next
+            // object is sufficient enough to be two-handed. This is done by checking if the movement
+            // from the current object to the next object and the movement from the current object
+            // to the significant move cursor occurrence produces an angle that is acute enough.
+            let isAngleFulfilled = false;
+            // For sliders, we need to consider two cases. The first case is when the player doesn't drag
+            // the slider. The second case is when the player drags the slider.
+            // TODO: check for cursor occurrences in nested objects
+            // Get the latest down or movement cursor occurrence.
+            while (c.occurrences[j]?.id === exports.movementType.UP &&
+                j > hitTimeBeforeIndex) {
+                --j;
+            }
+            if (object.object instanceof osuBase.Circle) {
+                // For circles, we only need to consider the actual press on the circle.
+                // Therefore, we need to get the latest down cursor occurrence instead.
+                while (c.occurrences[j]?.id !== exports.movementType.DOWN &&
+                    j > hitTimeBeforeIndex) {
+                    --j;
+                }
+            }
+            // Theoretically there can only be 1 up occurrence, but this is a
+            // consideration if the user manually adds cursor occurrences.
+            if (c.occurrences[j]?.id === exports.movementType.UP) {
+                ++j;
+            }
+            // Some move instances move in the exact same place. Not sure why, most likely
+            // because the position is recorded as int in the game and the movement is too small to
+            // convert into +1 or -1.
+            let nextSignificantOccurrenceIndex = j + 1;
+            while (c.occurrences[j] &&
+                c.occurrences[nextSignificantOccurrenceIndex] &&
+                c.occurrences[j].position.equals(c.occurrences[nextSignificantOccurrenceIndex].position)) {
+                ++nextSignificantOccurrenceIndex;
+            }
+            const nextSignificantOccurrence = c.occurrences[nextSignificantOccurrenceIndex];
+            const next = this.map.objects[index + 1];
+            if (nextSignificantOccurrence?.id === exports.movementType.MOVE && next) {
+                // Get the object's actual end position.
+                let actualEndPosition = object.object.stackedEndPosition;
+                if (object.object instanceof osuBase.Slider &&
+                    object.object.lazyEndPosition) {
+                    // For sliders, we take the closest distance between the lazy end position
+                    // and stacked end position towards the next significant cursor occurrence.
+                    // This assumes that the player takes the simpler movement.
+                    const lazyEndDistance = object.object.lazyEndPosition.getDistance(nextSignificantOccurrence.position);
+                    const actualEndDistance = object.object.stackedEndPosition.getDistance(nextSignificantOccurrence.position);
+                    if (lazyEndDistance < actualEndDistance) {
+                        actualEndPosition = object.object.lazyEndPosition;
+                    }
+                }
+                // Get the movement vector towards the next cursor occurrence by subtracting
+                // the next cursor occurrence with the object's position.
+                const movementVec = nextSignificantOccurrence.position.subtract(actualEndPosition);
+                const currentToNext = next.object.stackedPosition.subtract(actualEndPosition);
+                const dot = currentToNext.dot(movementVec);
+                const det = currentToNext.x * movementVec.y -
+                    currentToNext.y * movementVec.x;
+                const movementToNextAngle = Math.abs(Math.atan2(det, dot));
+                isAngleFulfilled = movementToNextAngle < Math.PI / 6;
+            }
+            cursorInformations.push({
+                // If the angle is fulfilled, we set the cursor index to the main cursor index.
+                cursorIndex: isAngleFulfilled ? i : -1,
+                distanceDiff: distance,
+            });
+        }
+        // Cursors have been filtered to see which of them is inside the object.
+        // Now we look at which cursor is closest to the center of the object.
+        const minDistanceDiff = Math.min(...cursorInformations.map((v) => {
+            return v.distanceDiff;
+        }));
+        return (cursorInformations.find((c) => c.distanceDiff === minDistanceDiff)
+            ?.cursorIndex ?? -1);
+    }
+    /**
+     * Applies penalty to the original star rating instance.
+     */
+    applyPenalty() {
+        const beatmaps = new Array(this.data.cursorMovement.length);
+        this.indexedHitObjects.forEach((o) => {
+            if (!beatmaps[o.cursorIndex]) {
+                const map = osuBase.Utils.deepCopy(this.map.map);
+                map.hitObjects.clear();
+                beatmaps[o.cursorIndex] = map;
+            }
+            beatmaps[o.cursorIndex].hitObjects.add(o.object.object);
+        });
+        // Keep rhythm values as we don't intend to calculate for them.
+        const rhythmValues = this.map.objects.map((v) => {
+            return {
+                strain: v.rhythmStrain,
+                multiplier: v.rhythmMultiplier,
+            };
+        });
+        this.map.objects.length = 0;
+        beatmaps.forEach((beatmap) => {
+            if (!beatmap) {
+                return;
+            }
+            const starRating = osuBase.Utils.deepCopy(this.map);
+            starRating.map = beatmap;
+            starRating.generateDifficultyHitObjects();
+            starRating.objects[0].deltaTime =
+                starRating.objects[0].startTime -
+                    this.indexedHitObjects[0].object.startTime;
+            starRating.objects[0].strainTime = Math.max(25, starRating.objects[0].deltaTime);
+            this.map.objects.push(...starRating.objects);
+        });
+        this.map.objects.sort((a, b) => a.startTime - b.startTime);
+        // Reassign rhythm values before calculating.
+        for (let i = 0; i < this.map.objects.length; ++i) {
+            this.map.objects[i].rhythmStrain = rhythmValues[i].strain;
+            this.map.objects[i].rhythmMultiplier = rhythmValues[i].multiplier;
+        }
+        // Do not include rhythm skill.
+        this.map.calculateAim();
+        this.map.calculateTap();
+        this.map.calculateFlashlight();
+        this.map.calculateVisual();
+        this.map.calculateTotal();
+    }
+}
+
+/**
+ * A replay analyzer that analyzes a replay from osu!droid.
+ *
+ * Created by reverse engineering the replay parser from the game itself, which can be found {@link https://github.com/osudroid/osu-droid/blob/master/src/ru/nsu/ccfit/zuev/osu/scoring/Replay.java here}.
+ *
+ * Once analyzed, the result can be accessed via the `data` property.
+ */
+class ReplayAnalyzer {
+    /**
+     * The score ID of the replay.
+     */
+    scoreID;
+    /**
+     * The original odr file of the replay.
+     */
+    originalODR = null;
+    /**
+     * The fixed odr file of the replay.
+     */
+    fixedODR = null;
+    /**
+     * Whether or not the play is considered using >=3 finger abuse.
+     */
+    is3Finger;
+    /**
+     * Whether or not the play is considered 2-handed.
+     */
+    is2Hand;
+    /**
+     * The beatmap that is being analyzed. `DroidStarRating` or `RebalanceDroidStarRating` is required for three finger or two hand analyzing.
+     */
+    map;
+    /**
+     * The results of the analyzer. `null` when initialized.
+     */
+    data = null;
+    /**
+     * Penalty value used to penalize dpp for 2-hand.
+     */
+    aimPenalty = 1;
+    /**
+     * Penalty value used to penalize dpp for 3 finger abuse.
+     */
+    tapPenalty = 1;
+    /**
+     * Whether this replay has been checked against 3 finger usage.
+     */
+    hasBeenCheckedFor3Finger = false;
+    /**
+     * Whether this replay has been checked against 2 hand usage.
+     */
+    hasBeenCheckedFor2Hand = false;
+    // Sizes of primitive data types in Java (in bytes)
+    BYTE_LENGTH = 1;
+    SHORT_LENGTH = 2;
+    INT_LENGTH = 4;
+    FLOAT_LENGTH = 4;
+    LONG_LENGTH = 8;
+    constructor(values) {
+        this.scoreID = values.scoreID;
+        this.map = values.map;
+    }
+    /**
+     * Analyzes a replay.
+     */
+    async analyze() {
+        if (!this.originalODR && !this.fixedODR) {
+            this.originalODR = await this.downloadReplay();
+        }
+        if (!this.originalODR) {
+            return this;
+        }
+        if (!this.fixedODR) {
+            this.fixedODR = await this.decompress().catch(() => {
+                return null;
+            });
+        }
+        if (!this.fixedODR) {
+            return this;
+        }
+        this.parseReplay();
+        return this;
+    }
+    /**
+     * Downloads the given score ID's replay.
+     */
+    async downloadReplay() {
+        const apiRequestBuilder = new osuBase.DroidAPIRequestBuilder()
+            .setRequireAPIkey(false)
+            .setEndpoint("upload")
+            .addParameter("", `${this.scoreID}.odr`);
+        const result = await apiRequestBuilder.sendRequest();
+        if (result.statusCode !== 200) {
+            return null;
+        }
+        return result.data;
+    }
+    /**
+     * Decompresses a replay.
+     *
+     * The decompressed replay is in a form of Java object. This will be converted to a buffer and deserialized to read data from the replay.
+     */
+    decompress() {
+        return new Promise((resolve, reject) => {
+            const stream$1 = new stream.Readable();
+            stream$1.push(this.originalODR);
+            stream$1.push(null);
+            stream$1
+                .pipe(unzipper.Parse())
+                .on("entry", async (entry) => {
+                const fileName = entry.path;
+                if (fileName === "data") {
+                    return resolve(await entry.buffer());
+                }
+                else {
+                    entry.autodrain();
+                }
+            })
+                .on("error", (e) => {
+                setTimeout(() => reject(e), 2000);
+            });
+        });
+    }
+    /**
+     * Parses a replay after being downloaded and converted to a buffer.
+     */
+    parseReplay() {
+        // javaDeserialization can only somewhat parse some string field
+        // the rest will be a buffer that we need to manually parse
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let rawObject;
+        try {
+            rawObject = javaDeserialization__namespace.parse(this.fixedODR);
+        }
+        catch {
+            return;
+        }
+        const resultObject = {
+            replayVersion: rawObject[0].version,
+            folderName: rawObject[1],
+            fileName: rawObject[2],
+            hash: rawObject[3],
+            cursorMovement: [],
+            hitObjectData: [],
+        };
+        if (resultObject.replayVersion >= 3) {
+            resultObject.time = new Date(Number(rawObject[4].readBigUInt64BE(0)));
+            resultObject.hit300k = rawObject[4].readInt32BE(8);
+            resultObject.hit100k = rawObject[4].readInt32BE(16);
+            resultObject.score = rawObject[4].readInt32BE(32);
+            resultObject.maxCombo = rawObject[4].readInt32BE(36);
+            resultObject.accuracy = new osuBase.Accuracy({
+                n300: rawObject[4].readInt32BE(12),
+                n100: rawObject[4].readInt32BE(20),
+                n50: rawObject[4].readInt32BE(24),
+                nmiss: rawObject[4].readInt32BE(28),
+            });
+            resultObject.isFullCombo = !!rawObject[4][44];
+            resultObject.playerName = rawObject[5];
+            resultObject.rawMods = rawObject[6].elements;
+            resultObject.convertedMods = this.convertMods(rawObject[6].elements);
+            // Determine rank
+            const totalHits = resultObject.accuracy.n300 +
+                resultObject.accuracy.n100 +
+                resultObject.accuracy.n50 +
+                resultObject.accuracy.nmiss;
+            const isHidden = resultObject.convertedMods.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModFlashlight);
+            const hit300Ratio = resultObject.accuracy.n300 / totalHits;
+            switch (true) {
+                case resultObject.accuracy.value() === 1:
+                    if (isHidden) {
+                        resultObject.rank = "XH";
+                    }
+                    else {
+                        resultObject.rank = "X";
+                    }
+                    break;
+                case hit300Ratio > 0.9 &&
+                    resultObject.accuracy.n50 / totalHits < 0.01 &&
+                    !resultObject.accuracy.nmiss:
+                    if (isHidden) {
+                        resultObject.rank = "SH";
+                    }
+                    else {
+                        resultObject.rank = "S";
+                    }
+                    break;
+                case (hit300Ratio > 0.8 && !resultObject.accuracy.nmiss) ||
+                    hit300Ratio > 0.9:
+                    resultObject.rank = "A";
+                    break;
+                case (hit300Ratio > 0.7 && !resultObject.accuracy.nmiss) ||
+                    hit300Ratio > 0.8:
+                    resultObject.rank = "B";
+                    break;
+                case hit300Ratio > 0.6:
+                    resultObject.rank = "C";
+                    break;
+                default:
+                    resultObject.rank = "D";
+            }
+        }
+        if (resultObject.replayVersion >= 4) {
+            const s = rawObject[7].split("|");
+            resultObject.speedModification =
+                parseFloat(s[0].replace("x", "")) || 1;
+            if (s.length > 1) {
+                resultObject.forcedAR = parseFloat(s[1].replace("AR", ""));
+            }
+        }
+        let bufferIndex;
+        switch (true) {
+            // replay v4 and above
+            case resultObject.replayVersion >= 4:
+                bufferIndex = 8;
+                break;
+            // replay v3
+            case resultObject.replayVersion === 3:
+                bufferIndex = 7;
+                break;
+            // replay v1 and v2
+            default:
+                bufferIndex = 4;
+        }
+        const replayDataBufferArray = [];
+        for (bufferIndex; bufferIndex < rawObject.length; ++bufferIndex) {
+            replayDataBufferArray.push(rawObject[bufferIndex]);
+        }
+        // Merge all cursor movement and hit object data section into one for better control when parsing
+        const replayDataBuffer = Buffer.concat(replayDataBufferArray);
+        let bufferCounter = 0;
+        const size = replayDataBuffer.readInt32BE(bufferCounter);
+        bufferCounter += this.INT_LENGTH;
+        // Parse movement data
+        for (let x = 0; x < size; x++) {
+            const moveSize = replayDataBuffer.readInt32BE(bufferCounter);
+            bufferCounter += this.INT_LENGTH;
+            const time = [];
+            const x = [];
+            const y = [];
+            const id = [];
+            for (let i = 0; i < moveSize; i++) {
+                time[i] = replayDataBuffer.readInt32BE(bufferCounter);
+                bufferCounter += this.INT_LENGTH;
+                id[i] = time[i] & 3;
+                time[i] >>= 2;
+                if (id[i] !== exports.movementType.UP) {
+                    if (resultObject.replayVersion >= 5) {
+                        x[i] = replayDataBuffer.readFloatBE(bufferCounter);
+                        bufferCounter += this.FLOAT_LENGTH;
+                        y[i] = replayDataBuffer.readFloatBE(bufferCounter);
+                        bufferCounter += this.FLOAT_LENGTH;
+                    }
+                    else {
+                        x[i] = replayDataBuffer.readInt16BE(bufferCounter);
+                        bufferCounter += this.SHORT_LENGTH;
+                        y[i] = replayDataBuffer.readInt16BE(bufferCounter);
+                        bufferCounter += this.SHORT_LENGTH;
+                    }
+                }
+                else {
+                    x[i] = -1;
+                    y[i] = -1;
+                }
+            }
+            resultObject.cursorMovement.push(new CursorData({
+                size: moveSize,
+                time: time,
+                x: x,
+                y: y,
+                id: id,
+            }));
+        }
+        const replayObjectLength = replayDataBuffer.readInt32BE(bufferCounter);
+        bufferCounter += this.INT_LENGTH;
+        // Parse result data
+        for (let i = 0; i < replayObjectLength; i++) {
+            const replayObjectData = {
+                accuracy: 0,
+                tickset: [],
+                result: 0,
+            };
+            replayObjectData.accuracy =
+                replayDataBuffer.readInt16BE(bufferCounter);
+            bufferCounter += this.SHORT_LENGTH;
+            const len = replayDataBuffer.readInt8(bufferCounter);
+            bufferCounter += this.BYTE_LENGTH;
+            if (len > 0) {
+                const bytes = [];
+                for (let j = 0; j < len; j++) {
+                    bytes.push(replayDataBuffer.readInt8(bufferCounter));
+                    bufferCounter += this.BYTE_LENGTH;
+                }
+                // Int/int division in Java; numbers must be truncated to get actual number
+                for (let j = 0; j < len * 8; j++) {
+                    replayObjectData.tickset[j] =
+                        (bytes[len - Math.trunc(j / 8) - 1] &
+                            (1 << Math.trunc(j % 8))) !==
+                            0;
+                }
+            }
+            if (resultObject.replayVersion >= 1) {
+                replayObjectData.result =
+                    replayDataBuffer.readInt8(bufferCounter);
+                bufferCounter += this.BYTE_LENGTH;
+            }
+            resultObject.hitObjectData.push(replayObjectData);
+        }
+        // Parse max combo, hit results, and accuracy in old replay version
+        if (resultObject.replayVersion < 3 && this.map) {
+            let hit300 = 0;
+            let hit300k = 0;
+            let hit100 = 0;
+            let hit100k = 0;
+            let hit50 = 0;
+            let hit0 = 0;
+            let grantsGekiOrKatu = true;
+            const objects = (this.map instanceof osuDifficultyCalculator.DroidStarRating ||
+                this.map instanceof osuRebalanceDifficultyCalculator.DroidStarRating
+                ? this.map.map
+                : this.map).hitObjects.objects;
+            for (let i = 0; i < resultObject.hitObjectData.length; ++i) {
+                // Hit result
+                const hitObjectData = resultObject.hitObjectData[i];
+                const isNextNewCombo = i + 1 !== objects.length ? objects[i + 1].isNewCombo : true;
+                switch (hitObjectData.result) {
+                    case exports.hitResult.RESULT_0:
+                        ++hit0;
+                        grantsGekiOrKatu = false;
+                        break;
+                    case exports.hitResult.RESULT_50:
+                        ++hit50;
+                        grantsGekiOrKatu = false;
+                        break;
+                    case exports.hitResult.RESULT_100:
+                        ++hit100;
+                        if (grantsGekiOrKatu && isNextNewCombo) {
+                            ++hit100k;
+                        }
+                        break;
+                    case exports.hitResult.RESULT_300:
+                        ++hit300;
+                        if (grantsGekiOrKatu && isNextNewCombo) {
+                            ++hit300k;
+                        }
+                        break;
+                }
+                if (isNextNewCombo) {
+                    grantsGekiOrKatu = true;
+                }
+            }
+            resultObject.hit300k = hit300k;
+            resultObject.hit100k = hit100k;
+            resultObject.accuracy = new osuBase.Accuracy({
+                n300: hit300,
+                n100: hit100,
+                n50: hit50,
+                nmiss: hit0,
+                nobjects: hit300 + hit100 + hit50 + hit0,
+            });
+            // Determine rank
+            const totalHits = resultObject.accuracy.n300 +
+                resultObject.accuracy.n100 +
+                resultObject.accuracy.n50 +
+                resultObject.accuracy.nmiss;
+            const isHidden = resultObject.convertedMods?.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModFlashlight) ?? false;
+            const hit300Ratio = resultObject.accuracy.n300 / totalHits;
+            switch (true) {
+                case resultObject.accuracy.value() === 1:
+                    if (isHidden) {
+                        resultObject.rank = "XH";
+                    }
+                    else {
+                        resultObject.rank = "X";
+                    }
+                    break;
+                case hit300Ratio > 0.9 &&
+                    resultObject.accuracy.n50 / totalHits < 0.01 &&
+                    !resultObject.accuracy.nmiss:
+                    if (isHidden) {
+                        resultObject.rank = "SH";
+                    }
+                    else {
+                        resultObject.rank = "S";
+                    }
+                    break;
+                case (hit300Ratio > 0.8 && !resultObject.accuracy.nmiss) ||
+                    hit300Ratio > 0.9:
+                    resultObject.rank = "A";
+                    break;
+                case (hit300Ratio > 0.7 && !resultObject.accuracy.nmiss) ||
+                    hit300Ratio > 0.8:
+                    resultObject.rank = "B";
+                    break;
+                case hit300Ratio > 0.6:
+                    resultObject.rank = "C";
+                    break;
+                default:
+                    resultObject.rank = "D";
+            }
+        }
+        this.data = new ReplayData(resultObject);
+    }
+    /**
+     * Gets hit error information of the replay.
+     *
+     * `analyze()` must be called before calling this.
+     */
+    calculateHitError() {
+        if (!this.data || !this.map) {
+            return null;
+        }
+        const hitObjectData = this.data.hitObjectData;
+        let positiveCount = 0;
+        let negativeCount = 0;
+        let positiveTotal = 0;
+        let negativeTotal = 0;
+        const objects = (this.map instanceof osuDifficultyCalculator.DroidStarRating ||
+            this.map instanceof osuRebalanceDifficultyCalculator.DroidStarRating
+            ? this.map.map
+            : this.map).hitObjects.objects;
+        for (let i = 0; i < hitObjectData.length; ++i) {
+            const v = hitObjectData[i];
+            const o = objects[i];
+            if (o instanceof osuBase.Spinner || v.result === exports.hitResult.RESULT_0) {
+                continue;
+            }
+            const accuracy = v.accuracy;
+            if (accuracy >= 0) {
+                positiveTotal += accuracy;
+                ++positiveCount;
+            }
+            else {
+                negativeTotal += accuracy;
+                ++negativeCount;
+            }
+        }
+        return {
+            positiveAvg: positiveTotal / positiveCount || 0,
+            negativeAvg: negativeTotal / negativeCount || 0,
+            unstableRate: osuBase.MathUtils.calculateStandardDeviation(hitObjectData.map((v, i) => v.result !== exports.hitResult.RESULT_0 &&
+                !(objects[i] instanceof osuBase.Spinner)
+                ? v.accuracy
+                : 0)) * 10,
+        };
+    }
+    /**
+     * Converts replay mods to droid mod string.
+     */
+    convertDroidMods(replayMods) {
+        const replayModsConstants = {
+            MOD_NOFAIL: "n",
+            MOD_EASY: "e",
+            MOD_HIDDEN: "h",
+            MOD_HARDROCK: "r",
+            MOD_DOUBLETIME: "d",
+            MOD_HALFTIME: "t",
+            MOD_NIGHTCORE: "c",
+            MOD_PRECISE: "s",
+            MOD_SMALLCIRCLE: "m",
+            MOD_SPEEDUP: "b",
+            MOD_REALLYEASY: "l",
+            MOD_PERFECT: "f",
+            MOD_SUDDENDEATH: "u",
+            MOD_SCOREV2: "v",
+        };
+        let modString = "";
+        for (const mod of replayMods) {
+            for (const property in replayModsConstants) {
+                if (!(property in replayModsConstants)) {
+                    continue;
+                }
+                if (!mod.includes(property)) {
+                    continue;
+                }
+                modString +=
+                    replayModsConstants[property];
+                break;
+            }
+        }
+        return modString;
+    }
+    /**
+     * Converts replay mods to regular mod string.
+     */
+    convertMods(replayMods) {
+        return osuBase.ModUtil.droidStringToMods(this.convertDroidMods(replayMods));
+    }
+    /**
+     * Checks if a play is using 3 fingers.
+     *
+     * Requires `analyze()` to be called first and `map` to be defined as `DroidStarRating` or `RebalanceDroidStarRating`.
+     */
+    checkFor3Finger() {
+        if (!(this.map instanceof osuDifficultyCalculator.DroidStarRating ||
+            this.map instanceof osuRebalanceDifficultyCalculator.DroidStarRating) ||
+            !this.data) {
+            return;
+        }
+        const threeFingerChecker = new ThreeFingerChecker(this.map, this.data);
+        const result = threeFingerChecker.check();
+        this.is3Finger = result.is3Finger;
+        this.tapPenalty = result.penalty;
+        this.hasBeenCheckedFor3Finger = true;
+    }
+    /**
+     * Checks if a play is using 2 hands.
+     *
+     * Requires `analyze()` to be called first and `map` to be defined as `DroidStarRating` or `RebalanceDroidStarRating`.
+     */
+    checkFor2Hand() {
+        if (!(this.map instanceof osuDifficultyCalculator.DroidStarRating ||
+            this.map instanceof osuRebalanceDifficultyCalculator.DroidStarRating) ||
+            !this.data) {
+            return;
+        }
+        const twoHandChecker = new TwoHandChecker(this.map, this.data);
+        this.is2Hand = twoHandChecker.check();
+        this.hasBeenCheckedFor2Hand = true;
+    }
+}
+
+/**
+ * Represents a hitobject in an osu!droid replay.
+ *
+ * Stores information about hitobjects in an osu!droid replay such as hit offset, tickset, and hit result.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+class ReplayObjectData {
+    /**
+     * The offset of which the hitobject was hit in milliseconds.
+     */
+    accuracy;
+    /**
+     * The tickset of the hitobject.
+     *
+     * This is used to determine whether or not a slider event (tick/repeat/end) is hit based on the order they appear.
+     */
+    tickset;
+    /**
+     * The bitwise hit result of the hitobject.
+     */
+    result;
+    constructor(values) {
+        this.accuracy = values.accuracy;
+        this.tickset = values.tickset;
+        this.result = values.result;
+    }
+}
+
+exports.CursorData = CursorData;
+exports.CursorOccurrence = CursorOccurrence;
+exports.ReplayAnalyzer = ReplayAnalyzer;
+exports.ReplayData = ReplayData;
+exports.ReplayObjectData = ReplayObjectData;
+exports.ThreeFingerChecker = ThreeFingerChecker;
+//# sourceMappingURL=index.js.map