@rian8337/osu-droid-replay-analyzer 1.0.0

package/dist/analysis/TwoHandChecker.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwoHandChecker = void 0;
+const osu_base_1 = require("@rian8337/osu-base");
+const __1 = require("..");
+const IndexedHitObject_1 = require("./objects/IndexedHitObject");
+/**
+ * Utility to check whether or not a beatmap is two-handed.
+ */
+class TwoHandChecker {
+    /**
+     * @param map The beatmap to analyze.
+     * @param data The data of the replay.
+     */
+    constructor(map, data) {
+        /**
+         * A cursor data array that only contains `movementType.DOWN` and `movementType.MOVE` movement ID occurrences.
+         */
+        this.downMoveCursorInstances = [];
+        /**
+         * The hitobjects of the beatmap that have been assigned with their respective cursor index.
+         */
+        this.indexedHitObjects = [];
+        /**
+         * 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.
+         */
+        this.minCursorIndexCount = 5;
+        this.map = map;
+        this.data = data;
+        const stats = new osu_base_1.MapStats({
+            od: this.map.map.od,
+            mods: this.map.mods.filter((m) => !osu_base_1.ModUtil.speedChangingMods
+                .map((v) => v.droidString)
+                .includes(m.droidString)),
+        }).calculate();
+        this.hitWindow = new osu_base_1.DroidHitWindow(stats.od);
+    }
+    /**
+     * Checks if a beatmap is two-handed.
+     */
+    check() {
+        this.filterCursorInstances();
+        if (this.downMoveCursorInstances.filter((v) => v.size > 0).length <= 1) {
+            return false;
+        }
+        this.indexHitObjects();
+        this.applyPenalty();
+        return true;
+    }
+    /**
+     * Filters the original cursor instances, returning only those with `movementType.DOWN` and `movementType.MOVE` movement ID.
+     */
+    filterCursorInstances() {
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const cursorInstance = this.data.cursorMovement[i];
+            const newCursorData = {
+                size: 0,
+                time: [],
+                x: [],
+                y: [],
+                id: [],
+            };
+            for (let j = 0; j < cursorInstance.size; ++j) {
+                if (cursorInstance.id[j] === __1.movementType.UP) {
+                    continue;
+                }
+                ++newCursorData.size;
+                newCursorData.time.push(cursorInstance.time[j]);
+                newCursorData.x.push(cursorInstance.x[j]);
+                newCursorData.y.push(cursorInstance.y[j]);
+                newCursorData.id.push(cursorInstance.id[j]);
+            }
+            this.downMoveCursorInstances.push(newCursorData);
+        }
+    }
+    /**
+     * Converts hitobjects into indexed hit objects.
+     */
+    indexHitObjects() {
+        const objects = this.map.objects;
+        const objectData = this.data.hitObjectData;
+        const indexes = [];
+        for (let i = 0; i < this.map.objects.length; ++i) {
+            const current = objects[i];
+            const currentData = objectData[i];
+            const index = this.getCursorIndex(current, currentData);
+            indexes.push(index);
+            this.indexedHitObjects.push(new IndexedHitObject_1.IndexedHitObject(current, index));
+        }
+        console.log(indexes.filter((v) => v !== -1).length, "cursors found,", indexes.filter((v) => v === -1).length, "not found");
+        const indexCounts = osu_base_1.Utils.initializeArray(this.downMoveCursorInstances.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) {
+                ignoredCursorIndexes.push(i);
+            }
+        }
+        this.indexedHitObjects.forEach((indexedHitObject) => {
+            if (indexedHitObject.cursorIndex === -1 ||
+                ignoredCursorIndexes.includes(indexedHitObject.cursorIndex)) {
+                indexedHitObject.cursorIndex = mainCursorIndex;
+            }
+        });
+        for (let i = 0; i < this.downMoveCursorInstances.length; ++i) {
+            console.log("Index", i, "count:", indexes.filter((v) => v === i).length);
+        }
+    }
+    /**
+     * Gets the cursor index that hits the given object.
+     *
+     * @param object The object to check.
+     * @param data The replay data of the object.
+     * @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(object, data) {
+        if (object.object instanceof osu_base_1.Spinner ||
+            data.result === __1.hitResult.RESULT_0) {
+            return -1;
+        }
+        const isPrecise = this.data.convertedMods.some((m) => m instanceof osu_base_1.ModPrecise);
+        let hitWindowLength;
+        switch (data.result) {
+            case __1.hitResult.RESULT_300:
+                hitWindowLength = this.hitWindow.hitWindowFor300(isPrecise);
+                break;
+            case __1.hitResult.RESULT_100:
+                hitWindowLength = this.hitWindow.hitWindowFor100(isPrecise);
+                break;
+            default:
+                hitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
+        }
+        const hitTime = object.object.startTime;
+        const maximumHitTime = hitTime + hitWindowLength;
+        const minimumHitTime = hitTime - hitWindowLength;
+        const cursorInformations = [];
+        for (let i = 0; i < this.downMoveCursorInstances.length; ++i) {
+            const c = this.downMoveCursorInstances[i];
+            let minDistance = Number.POSITIVE_INFINITY;
+            let minHitTime = 0;
+            for (let j = 0; j < c.size; ++j) {
+                if (c.time[j] < minimumHitTime) {
+                    continue;
+                }
+                // For some reason, some cursor instances repeat itself,
+                // so just skip it to save time.
+                if (c.time[j + 1] === c.time[j]) {
+                    continue;
+                }
+                if (c.time[j - 1] > maximumHitTime) {
+                    break;
+                }
+                let hitPosition = new osu_base_1.Vector2(c.x[j], c.y[j]);
+                let distanceToObject = object.object.stackedPosition.getDistance(hitPosition);
+                if (minDistance > distanceToObject) {
+                    minDistance = distanceToObject;
+                    minHitTime = c.time[j];
+                }
+                minDistance = Math.min(minDistance, object.object.stackedPosition.getDistance(hitPosition));
+                if (c.id[j + 1] === __1.movementType.MOVE ||
+                    c.id[j] === __1.movementType.MOVE) {
+                    // Interpolate cursor position between two occurrences
+                    const initialPosition = new osu_base_1.Vector2(c.x[j], c.y[j]);
+                    const nextPosition = new osu_base_1.Vector2(c.x[j + 1], c.y[j + 1]);
+                    const displacement = nextPosition.subtract(initialPosition);
+                    for (let mSecPassed = c.time[j]; mSecPassed <= Math.min(c.time[j + 1], maximumHitTime); ++mSecPassed) {
+                        const progress = (mSecPassed - c.time[j]) /
+                            (c.time[j + 1] - c.time[j]);
+                        hitPosition = initialPosition.add(displacement.scale(progress));
+                        distanceToObject =
+                            object.object.stackedPosition.getDistance(hitPosition);
+                        if (minDistance > distanceToObject) {
+                            minDistance = distanceToObject;
+                            minHitTime = mSecPassed;
+                        }
+                    }
+                }
+            }
+            if (minDistance <= object.object.radius) {
+                cursorInformations.push({
+                    cursorIndex: i,
+                    hitTimeDiff: Math.abs(minHitTime - hitTime),
+                });
+            }
+        }
+        if (cursorInformations.length === 0) {
+            return -1;
+        }
+        // Now we look at which cursor is closest to hit time
+        const minHitTimeDiff = Math.min(...cursorInformations.map((v) => {
+            return v.hitTimeDiff;
+        }));
+        return (cursorInformations.find((c) => c.hitTimeDiff === minHitTimeDiff)
+            ?.cursorIndex);
+    }
+    /**
+     * Applies penalty to the original star rating instance.
+     */
+    applyPenalty() {
+        const beatmaps = new Array(this.downMoveCursorInstances.length);
+        this.indexedHitObjects.forEach((o) => {
+            if (!beatmaps[o.cursorIndex]) {
+                const map = osu_base_1.Utils.deepCopy(this.map.map);
+                beatmaps[o.cursorIndex] = map;
+            }
+            beatmaps[o.cursorIndex].objects.push(o.object.object);
+        });
+        this.map.objects.length = 0;
+        beatmaps.forEach((beatmap) => {
+            if (!beatmap) {
+                return;
+            }
+            const starRating = osu_base_1.Utils.deepCopy(this.map);
+            starRating.map = beatmap;
+            starRating.generateDifficultyHitObjects(osu_base_1.modes.droid);
+            starRating.objects[0].deltaTime =
+                starRating.objects[0].object.startTime -
+                    this.indexedHitObjects[0].object.object.startTime;
+            starRating.objects[0].strainTime = Math.max(50, starRating.objects[0].deltaTime);
+            this.map.objects.push(...starRating.objects);
+        });
+        this.map.objects.sort((a, b) => {
+            return a.startTime - b.startTime;
+        });
+        this.map.calculateAll();
+    }
+}
+exports.TwoHandChecker = TwoHandChecker;

package/dist/analysis/data/BeatmapSection.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeatmapSection = void 0;
+/**
+ * Represents a section of a beatmap.
+ */
+class BeatmapSection {
+    /**
+     * @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;
+    }
+}
+exports.BeatmapSection = BeatmapSection;

package/dist/analysis/data/ThreeFingerBeatmapSection.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreeFingerBeatmapSection = void 0;
+const BeatmapSection_1 = require("./BeatmapSection");
+/**
+ * A section of a beatmap. This is used to detect dragged sections.
+ */
+class ThreeFingerBeatmapSection extends BeatmapSection_1.BeatmapSection {
+    constructor(values) {
+        super(values.firstObjectIndex, values.lastObjectIndex);
+        this.isDragged = values.isDragged;
+        this.dragFingerIndex = values.dragFingerIndex;
+    }
+}
+exports.ThreeFingerBeatmapSection = ThreeFingerBeatmapSection;

package/dist/analysis/objects/IndexedHitObject.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedHitObject = void 0;
+/**
+ * Contains information about which cursor index hits a hitobject.
+ */
+class IndexedHitObject {
+    /**
+     * @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;
+    }
+}
+exports.IndexedHitObject = IndexedHitObject;

package/dist/constants/hitResult.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hitResult = void 0;
+/**
+ * The result of a hit in an osu!droid replay.
+ */
+var hitResult;
+(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";
+})(hitResult = exports.hitResult || (exports.hitResult = {}));

package/dist/constants/movementType.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.movementType = void 0;
+/**
+ * Movement type of a cursor in an osu!droid replay.
+ */
+var movementType;
+(function (movementType) {
+    movementType[movementType["DOWN"] = 0] = "DOWN";
+    movementType[movementType["MOVE"] = 1] = "MOVE";
+    movementType[movementType["UP"] = 2] = "UP";
+})(movementType = exports.movementType || (exports.movementType = {}));

package/dist/data/CursorData.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CursorData = void 0;
+/**
+ * Represents a cursor instance in an osu!droid replay.
+ *
+ * Stores cursor movement data such as x and y coordinates, movement size, etc.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+class CursorData {
+    constructor(values) {
+        this.size = values.size;
+        this.time = values.time;
+        this.x = values.x;
+        this.y = values.y;
+        this.id = values.id;
+    }
+}
+exports.CursorData = CursorData;

package/dist/data/ReplayData.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayData = void 0;
+const osu_base_1 = require("@rian8337/osu-base");
+/**
+ * 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 {
+    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 osu_base_1.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;
+    }
+}
+exports.ReplayData = ReplayData;

package/dist/data/ReplayObjectData.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayObjectData = void 0;
+/**
+ * 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 {
+    constructor(values) {
+        this.accuracy = values.accuracy;
+        this.tickset = values.tickset;
+        this.result = values.result;
+    }
+}
+exports.ReplayObjectData = ReplayObjectData;

package/dist/index.js

@@ -0,0 +1,19 @@
+"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);

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@rian8337/osu-droid-replay-analyzer",
+  "version": "1.0.0",
+  "description": "A replay analyzer for analyzing osu!droid replay files.",
+  "keywords": [
+    "osu",
+    "osu-droid",
+    "osu-replay-analyzer"
+  ],
+  "author": "Rian8337 <52914632+Rian8337@users.noreply.github.com>",
+  "homepage": "https://github.com/Rian8337/osu-droid-module#readme",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "typings/index.d.ts",
+  "files": [
+    "dist/**",
+    "typings/**"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rian8337/osu-droid-module.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "dts-gen -m java-deserialization -o -f ./node_modules/java-deserialization/src/index.d.ts && npm run build",
+    "test": "echo \"No tests for this module\""
+  },
+  "bugs": {
+    "url": "https://github.com/Rian8337/osu-droid-module/issues"
+  },
+  "dependencies": {
+    "@rian8337/osu-base": "^1.0.0",
+    "@rian8337/osu-difficulty-calculator": "^1.0.0",
+    "@rian8337/osu-rebalance-difficulty-calculator": "^1.0.0",
+    "java-deserialization": "^0.1.0",
+    "unzipper": "^0.10.11"
+  },
+  "devDependencies": {
+    "@types/unzipper": "^0.10.5",
+    "dts-gen": "^0.6.0",
+    "typescript": "^4.5.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "e4fdb9c1ed6f90e70651c1aedfdb964b61cb240d"
+}