@rian8337/osu-difficulty-calculator 1.0.0

package/dist/skills/DroidFlashlight.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DroidFlashlight = void 0;
+const osu_base_1 = require("@rian8337/osu-base");
+const DroidSkill_1 = require("./DroidSkill");
+/**
+ * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
+ */
+class DroidFlashlight extends DroidSkill_1.DroidSkill {
+    constructor() {
+        super(...arguments);
+        this.historyLength = 10;
+        this.skillMultiplier = 0.15;
+        this.strainDecayBase = 0.15;
+        this.reducedSectionCount = 10;
+        this.reducedSectionBaseline = 0.75;
+        this.starsPerDouble = 1.05;
+    }
+    strainValueOf(current) {
+        if (current.object instanceof osu_base_1.Spinner) {
+            return 0;
+        }
+        const scalingFactor = 52 / current.object.radius;
+        let smallDistNerf = 1;
+        let cumulativeStrainTime = 0;
+        let result = 0;
+        for (let i = 0; i < this.previous.length; ++i) {
+            const previous = this.previous[i];
+            if (previous.object instanceof osu_base_1.Spinner) {
+                continue;
+            }
+            const jumpDistance = current.object.stackedPosition.subtract(previous.object.endPosition).length;
+            cumulativeStrainTime += previous.strainTime;
+            // We want to nerf objects that can be easily seen within the Flashlight circle radius.
+            if (i === 0) {
+                smallDistNerf = Math.min(1, jumpDistance / 75);
+            }
+            // We also want to nerf stacks so that only the first object of the stack is accounted for.
+            const stackNerf = Math.min(1, previous.lazyJumpDistance / scalingFactor / 25);
+            result +=
+                (Math.pow(0.8, i) * stackNerf * scalingFactor * jumpDistance) /
+                    cumulativeStrainTime;
+        }
+        return Math.pow(smallDistNerf * result, 2);
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueAt(current) {
+        this.currentStrain *= this.strainDecay(current.deltaTime);
+        this.currentStrain +=
+            this.strainValueOf(current) * this.skillMultiplier;
+        return this.currentStrain;
+    }
+    saveToHitObject(current) {
+        current.flashlightStrain = this.currentStrain;
+    }
+}
+exports.DroidFlashlight = DroidFlashlight;

package/dist/skills/DroidSkill.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DroidSkill = void 0;
+const StrainSkill_1 = require("../base/StrainSkill");
+/**
+ * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
+ * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
+ */
+class DroidSkill extends StrainSkill_1.StrainSkill {
+    difficultyValue() {
+        // Math here preserves the property that two notes of equal difficulty x, we have their summed difficulty = x * starsPerDouble.
+        // This also applies to two sets of notes with equal difficulty.
+        return Math.pow(this.strainPeaks.reduce((a, v) => a + Math.pow(v, 1 / Math.log2(this.starsPerDouble)), 0), Math.log2(this.starsPerDouble));
+    }
+}
+exports.DroidSkill = DroidSkill;

package/dist/skills/DroidTap.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DroidTap = void 0;
+const osu_base_1 = require("@rian8337/osu-base");
+const DroidSkill_1 = require("./DroidSkill");
+/**
+ * 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 DroidTap extends DroidSkill_1.DroidSkill {
+    constructor(mods, overallDifficulty) {
+        super(mods);
+        this.historyLength = 32;
+        this.skillMultiplier = 1375;
+        this.reducedSectionCount = 5;
+        this.reducedSectionBaseline = 0.75;
+        this.strainDecayBase = 0.3;
+        this.starsPerDouble = 1.1;
+        // ~200 1/4 BPM streams
+        this.minSpeedBonus = 75;
+        this.currentTapStrain = 0;
+        this.currentOriginalTapStrain = 0;
+        this.rhythmMultiplier = 0.75;
+        this.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
+        this.currentRhythm = 1;
+        this.overallDifficulty = overallDifficulty;
+        this.hitWindow = new osu_base_1.OsuHitWindow(this.overallDifficulty);
+    }
+    /**
+     * @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.hitWindow.hitWindowFor300() * 2;
+        // 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, strainTime / greatWindowFull);
+        }
+        // Cap deltatime to the OD 300 hitwindow.
+        // This equation is derived from making sure 260 BPM 1/4 OD7 streams aren't nerfed harshly.
+        strainTime /= osu_base_1.MathUtils.clamp(strainTime /
+            new osu_base_1.OsuHitWindow(this.overallDifficulty - 21.5).hitWindowFor300() /
+            0.35, 0.9, 1);
+        let speedBonus = 1;
+        if (strainTime < this.minSpeedBonus) {
+            speedBonus +=
+                0.75 * Math.pow((this.minSpeedBonus - strainTime) / 40, 2);
+        }
+        let originalSpeedBonus = 1;
+        if (current.strainTime < this.minSpeedBonus) {
+            originalSpeedBonus +=
+                0.75 *
+                    Math.pow((this.minSpeedBonus - current.strainTime) / 40, 2);
+        }
+        const decay = this.strainDecay(current.deltaTime);
+        this.currentRhythm = this.calculateRhythmBonus(current);
+        this.currentTapStrain *= decay;
+        this.currentTapStrain +=
+            this.tapStrainOf(speedBonus, strainTime) * this.skillMultiplier;
+        this.currentOriginalTapStrain *= decay;
+        this.currentOriginalTapStrain +=
+            this.tapStrainOf(originalSpeedBonus, current.strainTime) *
+                this.skillMultiplier;
+        return this.currentTapStrain * 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.hitWindow.hitWindowFor300() * 0.6) /
+                (this.hitWindow.hitWindowFor300() * 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;
+    }
+    /**
+     * Calculates the tap strain of a hitobject given a specific speed bonus and strain time.
+     */
+    tapStrainOf(speedBonus, strainTime) {
+        return speedBonus / strainTime;
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueAt(current) {
+        return this.strainValueOf(current);
+    }
+    /**
+     * @param current The hitobject to save to.
+     */
+    saveToHitObject(current) {
+        current.tapStrain = this.currentStrain;
+        current.rhythmMultiplier = this.currentRhythm;
+        current.originalTapStrain =
+            this.currentOriginalTapStrain * this.currentRhythm;
+    }
+}
+exports.DroidTap = DroidTap;

package/dist/skills/OsuAim.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OsuAim = void 0;
+const OsuSkill_1 = require("./OsuSkill");
+const osu_base_1 = require("@rian8337/osu-base");
+/**
+ * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
+ */
+class OsuAim extends OsuSkill_1.OsuSkill {
+    constructor(mods, withSliders) {
+        super(mods);
+        this.skillMultiplier = 23.25;
+        this.strainDecayBase = 0.15;
+        this.reducedSectionCount = 10;
+        this.reducedSectionBaseline = 0.75;
+        this.difficultyMultiplier = 1.06;
+        this.decayWeight = 0.9;
+        this.wideAngleMultiplier = 1.5;
+        this.acuteAngleMultiplier = 2;
+        this.sliderMultiplier = 1.5;
+        this.velocityChangeMultiplier = 0.75;
+        this.withSliders = withSliders;
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueOf(current) {
+        if (current.object instanceof osu_base_1.Spinner ||
+            this.previous.length <= 1 ||
+            this.previous[0].object instanceof osu_base_1.Spinner) {
+            return 0;
+        }
+        const last = this.previous[0];
+        const lastLast = this.previous[1];
+        // Calculate the velocity to the current hitobject, which starts with a base distance / time assuming the last object is a hitcircle.
+        let currentVelocity = current.lazyJumpDistance / current.strainTime;
+        // But if the last object is a slider, then we extend the travel velocity through the slider into the current object.
+        if (last.object instanceof osu_base_1.Slider && this.withSliders) {
+            // Calculate the slider velocity from slider head to slider end.
+            const travelVelocity = last.travelDistance / last.travelTime;
+            // Calculate the movement velocity from slider end to current object.
+            const movementVelocity = current.minimumJumpDistance / current.minimumJumpTime;
+            // Take the larger total combined velocity.
+            currentVelocity = Math.max(currentVelocity, movementVelocity + travelVelocity);
+        }
+        // As above, do the same for the previous hitobject.
+        let prevVelocity = last.lazyJumpDistance / last.strainTime;
+        if (lastLast.object instanceof osu_base_1.Slider && this.withSliders) {
+            const travelVelocity = lastLast.travelDistance / lastLast.travelTime;
+            const movementVelocity = last.minimumJumpDistance / last.minimumJumpTime;
+            prevVelocity = Math.max(prevVelocity, movementVelocity + travelVelocity);
+        }
+        let wideAngleBonus = 0;
+        let acuteAngleBonus = 0;
+        let sliderBonus = 0;
+        let velocityChangeBonus = 0;
+        // Start strain with regular velocity.
+        let strain = currentVelocity;
+        if (Math.max(current.strainTime, last.strainTime) <
+            1.25 * Math.min(current.strainTime, last.strainTime)) {
+            // If rhythms are the same.
+            if (current.angle !== null &&
+                last.angle !== null &&
+                lastLast.angle !== null) {
+                // Rewarding angles, take the smaller velocity as base.
+                const angleBonus = Math.min(currentVelocity, prevVelocity);
+                wideAngleBonus = this.calculateWideAngleBonus(current.angle);
+                acuteAngleBonus = this.calculateAcuteAngleBonus(current.angle);
+                // Only buff deltaTime exceeding 300 BPM 1/2.
+                if (current.strainTime > 100) {
+                    acuteAngleBonus = 0;
+                }
+                else {
+                    acuteAngleBonus *=
+                        // Multiply by previous angle, we don't want to buff unless this is a wiggle type pattern.
+                        this.calculateAcuteAngleBonus(last.angle) *
+                            // The maximum velocity we buff is equal to 125 / strainTime.
+                            Math.min(angleBonus, 125 / current.strainTime) *
+                            // Scale buff from 300 BPM 1/2 to 400 BPM 1/2.
+                            Math.pow(Math.sin((Math.PI / 2) *
+                                Math.min(1, (100 - current.strainTime) / 25)), 2) *
+                            // Buff distance exceeding 50 (radius) up to 100 (diameter).
+                            Math.pow(Math.sin(((Math.PI / 2) *
+                                (osu_base_1.MathUtils.clamp(current.lazyJumpDistance, 50, 100) -
+                                    50)) /
+                                50), 2);
+                }
+                // Penalize wide angles if they're repeated, reducing the penalty as last.angle gets more acute.
+                wideAngleBonus *=
+                    angleBonus *
+                        (1 -
+                            Math.min(wideAngleBonus, Math.pow(this.calculateWideAngleBonus(last.angle), 3)));
+                // Penalize acute angles if they're repeated, reducing the penalty as lastLast.angle gets more obtuse.
+                acuteAngleBonus *=
+                    0.5 +
+                        0.5 *
+                            (1 -
+                                Math.min(acuteAngleBonus, Math.pow(this.calculateAcuteAngleBonus(lastLast.angle), 3)));
+            }
+        }
+        if (Math.max(prevVelocity, currentVelocity)) {
+            // We want to use the average velocity over the whole object when awarding differences, not the individual jump and slider path velocities.
+            prevVelocity =
+                (last.lazyJumpDistance + lastLast.travelDistance) /
+                    last.strainTime;
+            currentVelocity =
+                (current.lazyJumpDistance + last.travelDistance) /
+                    current.strainTime;
+            // Scale with ratio of difference compared to half the max distance.
+            const distanceRatio = Math.pow(Math.sin(((Math.PI / 2) * Math.abs(prevVelocity - currentVelocity)) /
+                Math.max(prevVelocity, currentVelocity)), 2);
+            // Reward for % distance up to 125 / strainTime for overlaps where velocity is still changing.
+            const overlapVelocityBuff = Math.min(125 / Math.min(current.strainTime, last.strainTime), Math.abs(prevVelocity - currentVelocity));
+            // Reward for % distance slowed down compared to previous, paying attention to not award overlap.
+            const nonOverlapVelocityBuff = Math.abs(prevVelocity - currentVelocity) *
+                // Do not award overlap.
+                Math.pow(Math.sin((Math.PI / 2) *
+                    Math.min(1, Math.min(current.lazyJumpDistance, last.lazyJumpDistance) / 100)), 2);
+            // Choose the largest bonus, multiplied by ratio.
+            velocityChangeBonus =
+                Math.max(overlapVelocityBuff, nonOverlapVelocityBuff) *
+                    distanceRatio;
+            // Penalize for rhythm changes.
+            velocityChangeBonus *= Math.pow(Math.min(current.strainTime, last.strainTime) /
+                Math.max(current.strainTime, last.strainTime), 2);
+        }
+        if (last.travelTime) {
+            // Reward sliders based on velocity.
+            sliderBonus = last.travelDistance / last.travelTime;
+        }
+        // Add in acute angle bonus or wide angle bonus + velocity change bonus, whichever is larger.
+        strain += Math.max(acuteAngleBonus * this.acuteAngleMultiplier, wideAngleBonus * this.wideAngleMultiplier +
+            velocityChangeBonus * this.velocityChangeMultiplier);
+        // Add in additional slider velocity bonus.
+        if (this.withSliders) {
+            strain += sliderBonus * this.sliderMultiplier;
+        }
+        return strain;
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueAt(current) {
+        this.currentStrain *= this.strainDecay(current.deltaTime);
+        this.currentStrain +=
+            this.strainValueOf(current) * this.skillMultiplier;
+        return this.currentStrain;
+    }
+    /**
+     * @param current The hitobject to save to.
+     */
+    saveToHitObject(current) {
+        current.aimStrainWithSliders = this.currentStrain;
+    }
+    /**
+     * Calculates the bonus of wide angles.
+     */
+    calculateWideAngleBonus(angle) {
+        return Math.pow(Math.sin((3 / 4) *
+            (Math.min((5 / 6) * Math.PI, Math.max(Math.PI / 6, angle)) -
+                Math.PI / 6)), 2);
+    }
+    /**
+     * Calculates the bonus of acute angles.
+     */
+    calculateAcuteAngleBonus(angle) {
+        return 1 - this.calculateWideAngleBonus(angle);
+    }
+}
+exports.OsuAim = OsuAim;

package/dist/skills/OsuFlashlight.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OsuFlashlight = void 0;
+const osu_base_1 = require("@rian8337/osu-base");
+const OsuSkill_1 = require("./OsuSkill");
+/**
+ * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
+ */
+class OsuFlashlight extends OsuSkill_1.OsuSkill {
+    constructor() {
+        super(...arguments);
+        this.historyLength = 10;
+        this.skillMultiplier = 0.15;
+        this.strainDecayBase = 0.15;
+        this.reducedSectionCount = 10;
+        this.reducedSectionBaseline = 0.75;
+        this.difficultyMultiplier = 1.06;
+        this.decayWeight = 1;
+    }
+    strainValueOf(current) {
+        if (current.object instanceof osu_base_1.Spinner) {
+            return 0;
+        }
+        const scalingFactor = 52 / current.object.radius;
+        let smallDistNerf = 1;
+        let cumulativeStrainTime = 0;
+        let result = 0;
+        for (let i = 0; i < this.previous.length; ++i) {
+            const previous = this.previous[i];
+            if (previous.object instanceof osu_base_1.Spinner) {
+                continue;
+            }
+            const jumpDistance = current.object.stackedPosition.subtract(previous.object.endPosition).length;
+            cumulativeStrainTime += previous.strainTime;
+            // We want to nerf objects that can be easily seen within the Flashlight circle radius.
+            if (i === 0) {
+                smallDistNerf = Math.min(1, jumpDistance / 75);
+            }
+            // We also want to nerf stacks so that only the first object of the stack is accounted for.
+            const stackNerf = Math.min(1, previous.lazyJumpDistance / scalingFactor / 25);
+            result +=
+                (Math.pow(0.8, i) * stackNerf * scalingFactor * jumpDistance) /
+                    cumulativeStrainTime;
+        }
+        return Math.pow(smallDistNerf * result, 2);
+    }
+    /**
+     * @param current The hitobject to calculate.
+     */
+    strainValueAt(current) {
+        this.currentStrain *= this.strainDecay(current.deltaTime);
+        this.currentStrain +=
+            this.strainValueOf(current) * this.skillMultiplier;
+        return this.currentStrain;
+    }
+    saveToHitObject(current) {
+        current.flashlightStrain = this.currentStrain;
+    }
+}
+exports.OsuFlashlight = OsuFlashlight;

package/dist/skills/OsuSkill.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OsuSkill = void 0;
+const osu_base_1 = require("@rian8337/osu-base");
+const StrainSkill_1 = require("../base/StrainSkill");
+/**
+ * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
+ * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
+ */
+class OsuSkill extends StrainSkill_1.StrainSkill {
+    difficultyValue() {
+        let difficulty = 0;
+        let weight = 1;
+        const sortedStrains = this.strainPeaks
+            .slice()
+            .sort((a, b) => {
+            return b - a;
+        });
+        // We are reducing the highest strains first to account for extreme difficulty spikes.
+        for (let i = 0; i < Math.min(sortedStrains.length, this.reducedSectionCount); ++i) {
+            const scale = Math.log10(osu_base_1.Interpolation.lerp(1, 10, osu_base_1.MathUtils.clamp(i / this.reducedSectionCount, 0, 1)));
+            sortedStrains[i] *= osu_base_1.Interpolation.lerp(this.reducedSectionBaseline, 1, scale);
+        }
+        // Difficulty is the weighted sum of the highest strains from every section.
+        // We're sorting from highest to lowest strain.
+        sortedStrains
+            .sort((a, b) => {
+            return b - a;
+        })
+            .forEach((strain) => {
+            difficulty += strain * weight;
+            weight *= this.decayWeight;
+        });
+        return difficulty * this.difficultyMultiplier;
+    }
+}
+exports.OsuSkill = OsuSkill;