@rian8337/osu-difficulty-calculator 1.0.0

package/dist/skills/OsuSpeed.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OsuSpeed = void 0;
+const OsuSkill_1 = require("./OsuSkill");
+const osu_base_1 = require("@rian8337/osu-base");
+/**
+ * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
+ */
+class OsuSpeed extends OsuSkill_1.OsuSkill {
+    constructor(mods, greatWindow) {
+        super(mods);
+        /**
+         * Spacing threshold for a single hitobject spacing.
+         */
+        this.SINGLE_SPACING_THRESHOLD = 125;
+        this.historyLength = 32;
+        this.skillMultiplier = 1375;
+        this.strainDecayBase = 0.3;
+        this.reducedSectionCount = 5;
+        this.reducedSectionBaseline = 0.75;
+        this.difficultyMultiplier = 1.04;
+        this.decayWeight = 0.9;
+        this.rhythmMultiplier = 0.75;
+        this.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
+        this.currentSpeedStrain = 0;
+        this.currentRhythm = 0;
+        // ~200 1/4 BPM streams
+        this.minSpeedBonus = 75;
+        this.greatWindow = greatWindow;
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueOf(current) {
+        if (current.object instanceof osu_base_1.Spinner) {
+            return 0;
+        }
+        let strainTime = current.strainTime;
+        const greatWindowFull = this.greatWindow * 2;
+        const speedWindowRatio = strainTime / greatWindowFull;
+        // Aim to nerf cheesy rhythms (very fast consecutive doubles with large deltatimes between).
+        if (this.previous[0] &&
+            strainTime < greatWindowFull &&
+            this.previous[0].strainTime > strainTime) {
+            strainTime = osu_base_1.Interpolation.lerp(this.previous[0].strainTime, strainTime, speedWindowRatio);
+        }
+        // Cap deltatime to the OD 300 hitwindow.
+        // 0.93 is derived from making sure 260 BPM 1/4 OD8 streams aren't nerfed harshly, whilst 0.92 limits the effect of the cap.
+        strainTime /= osu_base_1.MathUtils.clamp(strainTime / greatWindowFull / 0.93, 0.92, 1);
+        let speedBonus = 1;
+        if (strainTime < this.minSpeedBonus) {
+            speedBonus +=
+                0.75 * Math.pow((this.minSpeedBonus - strainTime) / 40, 2);
+        }
+        const travelDistance = this.previous[0]?.travelDistance ?? 0;
+        const distance = Math.min(this.SINGLE_SPACING_THRESHOLD, travelDistance + current.lazyJumpDistance);
+        return ((speedBonus +
+            speedBonus *
+                Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 3.5)) /
+            strainTime);
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueAt(current) {
+        this.currentSpeedStrain *= this.strainDecay(current.deltaTime);
+        this.currentSpeedStrain +=
+            this.strainValueOf(current) * this.skillMultiplier;
+        this.currentRhythm = this.calculateRhythmBonus(current);
+        return this.currentSpeedStrain * this.currentRhythm;
+    }
+    /**
+     * Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current object.
+     */
+    calculateRhythmBonus(current) {
+        if (current.object instanceof osu_base_1.Spinner) {
+            return 0;
+        }
+        let previousIslandSize = 0;
+        let rhythmComplexitySum = 0;
+        let islandSize = 1;
+        // Store the ratio of the current start of an island to buff for tighter rhythms.
+        let startRatio = 0;
+        let firstDeltaSwitch = false;
+        let rhythmStart = 0;
+        while (rhythmStart < this.previous.length - 2 &&
+            current.startTime - this.previous[rhythmStart].startTime <
+                this.historyTimeMax) {
+            ++rhythmStart;
+        }
+        for (let i = rhythmStart; i > 0; --i) {
+            // Scale note 0 to 1 from history to now.
+            let currentHistoricalDecay = (this.historyTimeMax -
+                (current.startTime - this.previous[i - 1].startTime)) /
+                this.historyTimeMax;
+            // Either we're limited by time or limited by object count.
+            currentHistoricalDecay = Math.min(currentHistoricalDecay, (this.previous.length - i) / this.previous.length);
+            const currentDelta = this.previous[i - 1].strainTime;
+            const prevDelta = this.previous[i].strainTime;
+            const lastDelta = this.previous[i + 1].strainTime;
+            const currentRatio = 1 +
+                6 *
+                    Math.min(0.5, Math.pow(Math.sin(Math.PI /
+                        (Math.min(prevDelta, currentDelta) /
+                            Math.max(prevDelta, currentDelta))), 2));
+            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - this.greatWindow * 0.6) /
+                (this.greatWindow * 0.6));
+            let effectiveRatio = windowPenalty * currentRatio;
+            if (firstDeltaSwitch) {
+                if (prevDelta <= 1.25 * currentDelta &&
+                    prevDelta * 1.25 >= currentDelta) {
+                    // Island is still progressing, count size.
+                    if (islandSize < 7) {
+                        ++islandSize;
+                    }
+                }
+                else {
+                    if (this.previous[i - 1].object instanceof osu_base_1.Slider) {
+                        // BPM change is into slider, this is easy acc window.
+                        effectiveRatio /= 8;
+                    }
+                    if (this.previous[i].object instanceof osu_base_1.Slider) {
+                        // BPM change was from a slider, this is typically easier than circle -> circle.
+                        effectiveRatio /= 4;
+                    }
+                    if (previousIslandSize === islandSize) {
+                        // Repeated island size (ex: triplet -> triplet).
+                        effectiveRatio /= 4;
+                    }
+                    if (previousIslandSize % 2 === islandSize % 2) {
+                        // Repeated island polarity (2 -> 4, 3 -> 5).
+                        effectiveRatio /= 2;
+                    }
+                    if (lastDelta > prevDelta + 10 &&
+                        prevDelta > currentDelta + 10) {
+                        // Previous increase happened a note ago.
+                        // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
+                        effectiveRatio /= 8;
+                    }
+                    rhythmComplexitySum +=
+                        (((Math.sqrt(effectiveRatio * startRatio) *
+                            currentHistoricalDecay *
+                            Math.sqrt(4 + islandSize)) /
+                            2) *
+                            Math.sqrt(4 + previousIslandSize)) /
+                            2;
+                    startRatio = effectiveRatio;
+                    previousIslandSize = islandSize;
+                    if (prevDelta * 1.25 < currentDelta) {
+                        // We're slowing down, stop counting.
+                        // If we're speeding up, this stays as is and we keep counting island size.
+                        firstDeltaSwitch = false;
+                    }
+                    islandSize = 1;
+                }
+            }
+            else if (prevDelta > 1.25 * currentDelta) {
+                // We want to be speeding up.
+                // Begin counting island until we change speed again.
+                firstDeltaSwitch = true;
+                startRatio = effectiveRatio;
+                islandSize = 1;
+            }
+        }
+        return Math.sqrt(4 + rhythmComplexitySum * this.rhythmMultiplier) / 2;
+    }
+    /**
+     * @param current The hitobject to save to.
+     */
+    saveToHitObject(current) {
+        current.tapStrain = this.currentStrain;
+        current.rhythmMultiplier = this.currentRhythm;
+    }
+}
+exports.OsuSpeed = OsuSpeed;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@rian8337/osu-difficulty-calculator",
+  "version": "1.0.0",
+  "description": "A module for calculating osu!standard beatmap difficulty with respect to the current difficulty and performance algorithm.",
+  "keywords": [
+    "osu",
+    "osu-difficulty-calculator"
+  ],
+  "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": "npm run build",
+    "test": "jest -i"
+  },
+  "bugs": {
+    "url": "https://github.com/Rian8337/osu-droid-module/issues"
+  },
+  "dependencies": {
+    "@rian8337/osu-base": "^1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "e4fdb9c1ed6f90e70651c1aedfdb964b61cb240d"
+}