@rian8337/osu-difficulty-calculator 4.0.0-beta.63 → 4.0.0-beta.65

package/dist/index.js

@@ -65,19 +65,17 @@ class DifficultyCalculator {
         /**
          * `Mod`s that adjust the difficulty of a beatmap.
          */
-        this.difficultyAdjustmentMods = new Set([
-            osuBase.ModDoubleTime,
-            osuBase.ModNightCore,
+        this.difficultyAdjustmentMods = [
             osuBase.ModDifficultyAdjust,
-            osuBase.ModCustomSpeed,
-            osuBase.ModHalfTime,
+            osuBase.ModRateAdjust,
             osuBase.ModEasy,
             osuBase.ModHardRock,
             osuBase.ModFlashlight,
             osuBase.ModHidden,
             osuBase.ModRelax,
             osuBase.ModAutopilot,
-        ]);
+            osuBase.ModMirror,
+        ];
     }
     calculate(beatmap, mods) {
         const playableBeatmap = beatmap instanceof osuBase.PlayableBeatmap
@@ -145,11 +143,11 @@ class DifficultyHitObject {
      *
      * @param object The underlying hitobject.
      * @param lastObject The hitobject before this hitobject.
-     * @param lastLastObject The hitobject before the last hitobject.
      * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
      * @param clockRate The clock rate of the beatmap.
+     * @param index The index of this hitobject in the list of all hitobjects.
      */
-    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, index) {
+    constructor(object, lastObject, difficultyHitObjects, clockRate, index) {
         var _a, _b, _c, _d;
         /**
          * The aim strain generated by the hitobject if sliders are considered.
@@ -194,6 +192,16 @@ class DifficultyHitObject {
          * The time taken to travel through `travelDistance`, with a minimum value of 25ms for sliders.
          */
         this.travelTime = 0;
+        /**
+         * The distance travelled by the cursor upon completion of this hitobject if it was hit
+         * with as few movements as possible.
+         */
+        this.lazyTravelDistance = 0;
+        /**
+         * The time taken by the cursor upon completion of this hitobject if it was hit with
+         * as few movements as possible.
+         */
+        this.lazyTravelTime = 0;
         /**
          * Angle the player has to take to hit this hitobject.
          *
@@ -204,7 +212,6 @@ class DifficultyHitObject {
         this.assumedSliderRadius = DifficultyHitObject.normalizedRadius * 1.8;
         this.object = object;
         this.lastObject = lastObject;
-        this.lastLastObject = lastLastObject;
         this.hitObjects = difficultyHitObjects;
         if (object instanceof osuBase.Slider) {
             this.fullGreatWindow =
@@ -226,6 +233,8 @@ class DifficultyHitObject {
             this.deltaTime = 0;
             this.strainTime = 0;
         }
+        this.lastDifficultyObject = this.previous(0);
+        this.lastLastDifficultyObject = this.previous(1);
     }
     /**
      * Computes the properties of this hitobject.
@@ -237,6 +246,7 @@ class DifficultyHitObject {
     // Required for `DroidDifficultyHitObject` override.
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     hitObjects) {
+        this.calculateSliderCursorPosition();
         this.setDistances(clockRate);
     }
     /**
@@ -311,8 +321,8 @@ class DifficultyHitObject {
     }
     setDistances(clockRate) {
         if (this.object instanceof osuBase.Slider) {
-            this.calculateSliderCursorPosition(this.object);
-            this.travelDistance = this.object.lazyTravelDistance;
+            this.calculateSliderCursorPosition();
+            this.travelDistance = this.lazyTravelDistance;
             // Bonus for repeat sliders until a better per nested object strain system can be achieved.
             if (this.mode === osuBase.Modes.droid) {
                 this.travelDistance *= Math.pow(1 + this.object.repeatCount / 4, 1 / 4);
@@ -320,7 +330,7 @@ class DifficultyHitObject {
             else {
                 this.travelDistance *= Math.pow(1 + this.object.repeatCount / 2.5, 1 / 2.5);
             }
-            this.travelTime = Math.max(this.object.lazyTravelTime / clockRate, DifficultyHitObject.minDeltaTime);
+            this.travelTime = Math.max(this.lazyTravelTime / clockRate, DifficultyHitObject.minDeltaTime);
         }
         // We don't need to calculate either angle or distance when one of the last->curr objects is a spinner.
         if (!this.lastObject ||
@@ -330,15 +340,18 @@ class DifficultyHitObject {
         }
         // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
         const { scalingFactor } = this;
-        const lastCursorPosition = this.getEndCursorPosition(this.lastObject);
+        const lastCursorPosition = this.lastDifficultyObject !== null
+            ? this.getEndCursorPosition(this.lastDifficultyObject)
+            : this.lastObject.getStackedPosition(this.mode);
         this.lazyJumpDistance = this.object
             .getStackedPosition(this.mode)
             .scale(scalingFactor)
             .subtract(lastCursorPosition.scale(scalingFactor)).length;
         this.minimumJumpTime = this.strainTime;
         this.minimumJumpDistance = this.lazyJumpDistance;
-        if (this.lastObject instanceof osuBase.Slider) {
-            const lastTravelTime = Math.max(this.lastObject.lazyTravelTime / clockRate, DifficultyHitObject.minDeltaTime);
+        if (this.lastObject instanceof osuBase.Slider &&
+            this.lastDifficultyObject !== null) {
+            const lastTravelTime = Math.max(this.lastDifficultyObject.lazyTravelTime / clockRate, DifficultyHitObject.minDeltaTime);
             this.minimumJumpTime = Math.max(this.strainTime - lastTravelTime, DifficultyHitObject.minDeltaTime);
             // There are two types of slider-to-object patterns to consider in order to better approximate the real movement a player will take to jump between the hitobjects.
             //
@@ -366,8 +379,9 @@ class DifficultyHitObject {
             this.minimumJumpDistance = Math.max(0, Math.min(this.lazyJumpDistance -
                 (this.maximumSliderRadius - this.assumedSliderRadius), tailJumpDistance - this.maximumSliderRadius));
         }
-        if (this.lastLastObject && !(this.lastLastObject instanceof osuBase.Spinner)) {
-            const lastLastCursorPosition = this.getEndCursorPosition(this.lastLastObject);
+        if (this.lastLastDifficultyObject &&
+            !(this.lastLastDifficultyObject.object instanceof osuBase.Spinner)) {
+            const lastLastCursorPosition = this.getEndCursorPosition(this.lastLastDifficultyObject);
             const v1 = lastLastCursorPosition.subtract(this.lastObject.getStackedPosition(this.mode));
             const v2 = this.object
                 .getStackedPosition(this.mode)
@@ -377,14 +391,14 @@ class DifficultyHitObject {
             this.angle = Math.abs(Math.atan2(det, dot));
         }
     }
-    calculateSliderCursorPosition(slider) {
-        if (slider.lazyEndPosition) {
+    calculateSliderCursorPosition() {
+        if (!(this.object instanceof osuBase.Slider) || this.lazyEndPosition) {
             return;
         }
-        let trackingEndTime = slider.endTime;
-        let { nestedHitObjects: nestedObjects } = slider;
+        let trackingEndTime = this.object.endTime;
+        let { nestedHitObjects: nestedObjects } = this.object;
         if (this.mode === osuBase.Modes.osu) {
-            trackingEndTime = Math.max(slider.endTime - osuBase.Slider.legacyLastTickOffset, slider.startTime + slider.duration / 2);
+            trackingEndTime = Math.max(this.object.endTime - osuBase.Slider.legacyLastTickOffset, this.object.startTime + this.object.duration / 2);
             let lastRealTick = null;
             for (let i = nestedObjects.length - 2; i > 0; --i) {
                 const current = nestedObjects[i];
@@ -413,15 +427,15 @@ class DifficultyHitObject {
         }
         if (this.mode === osuBase.Modes.droid) {
             // Temporary lazy end position until a real result can be derived.
-            slider.lazyEndPosition = slider.getStackedPosition(this.mode);
+            this.lazyEndPosition = this.object.getStackedPosition(this.mode);
             // Stop here if the slider has too short duration, allowing the player to essentially
             // complete the slider without movement, making travel distance and time irrelevant.
-            if (osuBase.Precision.almostEqualsNumber(slider.startTime, slider.endTime)) {
+            if (osuBase.Precision.almostEqualsNumber(this.object.startTime, this.object.endTime)) {
                 return;
             }
         }
-        slider.lazyTravelTime = trackingEndTime - slider.startTime;
-        let endTimeMin = slider.lazyTravelTime / slider.spanDuration;
+        this.lazyTravelTime = trackingEndTime - this.object.startTime;
+        let endTimeMin = this.lazyTravelTime / this.object.spanDuration;
         if (endTimeMin % 2 >= 1) {
             endTimeMin = 1 - (endTimeMin % 1);
         }
@@ -429,11 +443,11 @@ class DifficultyHitObject {
             endTimeMin %= 1;
         }
         // Temporary lazy end position until a real result can be derived.
-        slider.lazyEndPosition = slider
+        this.lazyEndPosition = this.object
             .getStackedPosition(this.mode)
-            .add(slider.path.positionAt(endTimeMin));
-        let currentCursorPosition = slider.getStackedPosition(this.mode);
-        const scalingFactor = DifficultyHitObject.normalizedRadius / slider.radius;
+            .add(this.object.path.positionAt(endTimeMin));
+        let currentCursorPosition = this.object.getStackedPosition(this.mode);
+        const scalingFactor = DifficultyHitObject.normalizedRadius / this.object.radius;
         for (let i = 1; i < nestedObjects.length; ++i) {
             const currentMovementObject = nestedObjects[i];
             let currentMovement = currentMovementObject
@@ -447,7 +461,7 @@ class DifficultyHitObject {
                 // There is both a lazy end position as well as the actual end slider position. We assume the player takes the simpler movement.
                 // For sliders that are circular, the lazy end position may actually be farther away than the sliders' true end.
                 // This code is designed to prevent buffing situations where lazy end is actually a less efficient movement.
-                const lazyMovement = slider.lazyEndPosition.subtract(currentCursorPosition);
+                const lazyMovement = this.lazyEndPosition.subtract(currentCursorPosition);
                 if (lazyMovement.length < currentMovement.length) {
                     currentMovement = lazyMovement;
                 }
@@ -465,21 +479,16 @@ class DifficultyHitObject {
                 currentMovementLength *=
                     (currentMovementLength - requiredMovement) /
                         currentMovementLength;
-                slider.lazyTravelDistance += currentMovementLength;
+                this.lazyTravelDistance += currentMovementLength;
             }
             if (i === nestedObjects.length - 1) {
-                slider.lazyEndPosition = currentCursorPosition;
+                this.lazyEndPosition = currentCursorPosition;
             }
         }
     }
     getEndCursorPosition(object) {
         var _a;
-        let pos = object.getStackedPosition(this.mode);
-        if (object instanceof osuBase.Slider) {
-            this.calculateSliderCursorPosition(object);
-            pos = (_a = object.lazyEndPosition) !== null && _a !== void 0 ? _a : pos;
-        }
-        return pos;
+        return ((_a = object.lazyEndPosition) !== null && _a !== void 0 ? _a : object.object.getStackedPosition(this.mode));
     }
 }
 /**
@@ -512,12 +521,11 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
      *
      * @param object The underlying hitobject.
      * @param lastObject The hitobject before this hitobject.
-     * @param lastLastObject The hitobject before the last hitobject.
      * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
      * @param clockRate The clock rate of the beatmap.
      */
-    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, index) {
-        super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate, index);
+    constructor(object, lastObject, difficultyHitObjects, clockRate, index) {
+        super(object, lastObject, difficultyHitObjects, clockRate, index);
         /**
          * The tap strain generated by the hitobject.
          */
@@ -1198,7 +1206,7 @@ class DroidFlashlightEvaluator {
         let sliderBonus = 0;
         if (current.object instanceof osuBase.Slider && withSliders) {
             // Invert the scaling factor to determine the true travel distance independent of circle size.
-            const pixelTravelDistance = current.object.lazyTravelDistance / scalingFactor;
+            const pixelTravelDistance = current.lazyTravelDistance / scalingFactor;
             // Reward sliders based on velocity.
             sliderBonus = Math.pow(Math.max(0, pixelTravelDistance / current.travelTime - this.minVelocity), 0.5);
             // Longer sliders require more memorization.
@@ -1688,7 +1696,7 @@ class DroidVisualEvaluator {
         if (current.object instanceof osuBase.Slider && withSliders) {
             const scalingFactor = 50 / current.object.radius;
             // Invert the scaling factor to determine the true travel distance independent of circle size.
-            const pixelTravelDistance = current.object.lazyTravelDistance / scalingFactor;
+            const pixelTravelDistance = current.lazyTravelDistance / scalingFactor;
             const currentVelocity = pixelTravelDistance / current.travelTime;
             const spanTravelDistance = pixelTravelDistance / current.object.spanCount;
             strain +=
@@ -1707,7 +1715,7 @@ class DroidVisualEvaluator {
                     continue;
                 }
                 // Invert the scaling factor to determine the true travel distance independent of circle size.
-                const lastPixelTravelDistance = last.object.lazyTravelDistance / scalingFactor;
+                const lastPixelTravelDistance = last.lazyTravelDistance / scalingFactor;
                 const lastVelocity = lastPixelTravelDistance / last.travelTime;
                 const lastSpanTravelDistance = lastPixelTravelDistance / last.object.spanCount;
                 strain +=
@@ -1799,15 +1807,12 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     constructor() {
         super();
         this.difficultyMultiplier = 0.18;
-        this.difficultyAdjustmentMods
-            .add(osuBase.ModPrecise)
-            .add(osuBase.ModScoreV2)
-            .add(osuBase.ModTraceable);
+        this.difficultyAdjustmentMods.push(osuBase.ModPrecise, osuBase.ModScoreV2, osuBase.ModTraceable);
     }
     retainDifficultyAdjustmentMods(mods) {
         return mods.filter((mod) => mod.isApplicableToDroid() &&
-            this.difficultyAdjustmentMods.has(mod.constructor) &&
-            mod.isDroidRelevant);
+            mod.isDroidRelevant &&
+            this.difficultyAdjustmentMods.some((m) => mod instanceof m));
     }
     createDifficultyAttributes(beatmap, skills, objects) {
         const attributes = new ExtendedDroidDifficultyAttributes();
@@ -1868,12 +1873,12 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         return beatmap.createDroidPlayableBeatmap(mods);
     }
     createDifficultyHitObjects(beatmap) {
-        var _a, _b;
+        var _a;
         const clockRate = beatmap.speedMultiplier;
         const difficultyObjects = [];
         const { objects } = beatmap.hitObjects;
         for (let i = 0; i < objects.length; ++i) {
-            const difficultyObject = new DroidDifficultyHitObject(objects[i], (_a = objects[i - 1]) !== null && _a !== void 0 ? _a : null, (_b = objects[i - 2]) !== null && _b !== void 0 ? _b : null, difficultyObjects, clockRate, i - 1);
+            const difficultyObject = new DroidDifficultyHitObject(objects[i], (_a = objects[i - 1]) !== null && _a !== void 0 ? _a : null, difficultyObjects, clockRate, i - 1);
             difficultyObject.computeProperties(clockRate, objects);
             difficultyObjects.push(difficultyObject);
         }
@@ -3132,7 +3137,7 @@ class OsuFlashlightEvaluator {
         let sliderBonus = 0;
         if (current.object instanceof osuBase.Slider) {
             // Invert the scaling factor to determine the true travel distance independent of circle size.
-            const pixelTravelDistance = current.object.lazyTravelDistance / scalingFactor;
+            const pixelTravelDistance = current.lazyTravelDistance / scalingFactor;
             // Reward sliders based on velocity.
             sliderBonus = Math.pow(Math.max(0, pixelTravelDistance / current.travelTime - this.minVelocity), 0.5);
             // Longer sliders require more memorization.
@@ -3452,12 +3457,12 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
     constructor() {
         super();
         this.difficultyMultiplier = 0.0675;
-        this.difficultyAdjustmentMods.add(osuBase.ModTouchDevice);
+        this.difficultyAdjustmentMods.push(osuBase.ModTouchDevice);
     }
     retainDifficultyAdjustmentMods(mods) {
         return mods.filter((mod) => mod.isApplicableToOsu() &&
-            this.difficultyAdjustmentMods.has(mod.constructor) &&
-            mod.isOsuRelevant);
+            mod.isOsuRelevant &&
+            this.difficultyAdjustmentMods.some((m) => mod instanceof m));
     }
     createDifficultyAttributes(beatmap, skills) {
         const attributes = new OsuDifficultyAttributes();
@@ -3508,12 +3513,11 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         return beatmap.createOsuPlayableBeatmap(mods);
     }
     createDifficultyHitObjects(beatmap) {
-        var _a;
         const clockRate = beatmap.speedMultiplier;
         const difficultyObjects = [];
         const { objects } = beatmap.hitObjects;
         for (let i = 1; i < objects.length; ++i) {
-            const difficultyObject = new OsuDifficultyHitObject(objects[i], objects[i - 1], (_a = objects[i - 2]) !== null && _a !== void 0 ? _a : null, difficultyObjects, clockRate, i - 1);
+            const difficultyObject = new OsuDifficultyHitObject(objects[i], objects[i - 1], difficultyObjects, clockRate, i - 1);
             difficultyObject.computeProperties(clockRate, objects);
             difficultyObjects.push(difficultyObject);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.63",
+    "version": "4.0.0-beta.65",
     "description": "A module for calculating osu!standard beatmap difficulty and performance value with respect to the current difficulty and performance algorithm.",
     "keywords": [
         "osu",
@@ -33,10 +33,10 @@
         "url": "https://github.com/Rian8337/osu-droid-module/issues"
     },
     "dependencies": {
-        "@rian8337/osu-base": "^4.0.0-beta.63"
+        "@rian8337/osu-base": "^4.0.0-beta.65"
     },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "2c895348d95de4e6cf2a783815e6c5f8a442620f"
+    "gitHead": "7fde5e9b7f6240fc962a2ce3866d63059ff65767"
 }

package/typings/index.d.ts

@@ -1,4 +1,4 @@
-import { ModMap, SerializedMod, PlaceableHitObject, Modes, PlayableBeatmap, Mod, Beatmap, DroidPlayableBeatmap, Accuracy, OsuPlayableBeatmap } from '@rian8337/osu-base';
+import { ModMap, SerializedMod, PlaceableHitObject, Vector2, Modes, PlayableBeatmap, Mod, Beatmap, DroidPlayableBeatmap, Accuracy, OsuPlayableBeatmap } from '@rian8337/osu-base';
 
 /**
  * Holds data that can be used to calculate performance points.
@@ -168,6 +168,21 @@ declare abstract class DifficultyHitObject {
      * The time taken to travel through `travelDistance`, with a minimum value of 25ms for sliders.
      */
     travelTime: number;
+    /**
+     * The position of the cursor at the point of completion of this hitobject if it was hit
+     * with as few movements as possible.
+     */
+    lazyEndPosition?: Vector2;
+    /**
+     * The distance travelled by the cursor upon completion of this hitobject if it was hit
+     * with as few movements as possible.
+     */
+    lazyTravelDistance: number;
+    /**
+     * The time taken by the cursor upon completion of this hitobject if it was hit with
+     * as few movements as possible.
+     */
+    lazyTravelTime: number;
     /**
      * Angle the player has to take to hit this hitobject.
      *
@@ -214,18 +229,19 @@ declare abstract class DifficultyHitObject {
      */
     static readonly minDeltaTime = 25;
     private readonly lastObject;
-    private readonly lastLastObject;
+    private readonly lastDifficultyObject;
+    private readonly lastLastDifficultyObject;
     /**
      * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
      * overridden properties (see [this](https://github.com/microsoft/TypeScript/issues/1617) GitHub issue).
      *
      * @param object The underlying hitobject.
      * @param lastObject The hitobject before this hitobject.
-     * @param lastLastObject The hitobject before the last hitobject.
      * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
      * @param clockRate The clock rate of the beatmap.
+     * @param index The index of this hitobject in the list of all hitobjects.
      */
-    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, index: number);
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, index: number);
     /**
      * Computes the properties of this hitobject.
      *
@@ -414,7 +430,7 @@ declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, TH
     /**
      * `Mod`s that adjust the difficulty of a beatmap.
      */
-    protected readonly difficultyAdjustmentMods: Set<typeof Mod>;
+    protected readonly difficultyAdjustmentMods: (typeof Mod)[];
     /**
      * Retains `Mod`s that adjust a beatmap's difficulty from the specified mods.
      *
@@ -581,11 +597,10 @@ declare class DroidDifficultyHitObject extends DifficultyHitObject {
      *
      * @param object The underlying hitobject.
      * @param lastObject The hitobject before this hitobject.
-     * @param lastLastObject The hitobject before the last hitobject.
      * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
      * @param clockRate The clock rate of the beatmap.
      */
-    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, index: number);
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, index: number);
     computeProperties(clockRate: number, hitObjects: readonly PlaceableHitObject[]): void;
     opacityAt(time: number, mods: ModMap): number;
     previous(backwardsIndex: number): this | null;