@rian8337/osu-difficulty-calculator 4.0.0-beta.66 → 4.0.0-beta.69

package/dist/index.js

@@ -75,12 +75,17 @@ class DifficultyCalculator {
             osuBase.ModRelax,
             osuBase.ModAutopilot,
             osuBase.ModMirror,
+            osuBase.ModRandom,
         ];
     }
     calculate(beatmap, mods) {
+        const difficultyAdjustmentMods = this.retainDifficultyAdjustmentMods(mods ? Array.from(mods.values()) : []);
         const playableBeatmap = beatmap instanceof osuBase.PlayableBeatmap
             ? beatmap
-            : this.createPlayableBeatmap(beatmap, mods);
+            : this.createPlayableBeatmap(beatmap, new osuBase.ModMap(difficultyAdjustmentMods.map((m) => [
+                m.constructor,
+                m,
+            ])));
         const skills = this.createSkills(playableBeatmap);
         const objects = this.createDifficultyHitObjects(playableBeatmap);
         for (const object of objects) {
@@ -342,9 +347,8 @@ class DifficultyHitObject {
         const { scalingFactor } = this;
         const lastCursorPosition = this.lastDifficultyObject !== null
             ? this.getEndCursorPosition(this.lastDifficultyObject)
-            : this.lastObject.getStackedPosition(this.mode);
-        this.lazyJumpDistance = this.object
-            .getStackedPosition(this.mode)
+            : this.lastObject.stackedPosition;
+        this.lazyJumpDistance = this.object.stackedPosition
             .scale(scalingFactor)
             .subtract(lastCursorPosition.scale(scalingFactor)).length;
         this.minimumJumpTime = this.strainTime;
@@ -372,20 +376,15 @@ class DifficultyHitObject {
             // In this case the most natural jump path is better approximated by a new distance called "tailJumpDistance" - the distance between the slider's tail and the next hitobject.
             //
             // Thus, the player is assumed to jump the minimum of these two distances in all cases.
-            const tailJumpDistance = this.lastObject.tail
-                .getStackedPosition(this.mode)
-                .subtract(this.object.getStackedPosition(this.mode))
-                .length * scalingFactor;
+            const tailJumpDistance = this.lastObject.tail.stackedPosition.subtract(this.object.stackedPosition).length * scalingFactor;
             this.minimumJumpDistance = Math.max(0, Math.min(this.lazyJumpDistance -
                 (this.maximumSliderRadius - this.assumedSliderRadius), tailJumpDistance - this.maximumSliderRadius));
         }
         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)
-                .subtract(lastCursorPosition);
+            const v1 = lastLastCursorPosition.subtract(this.lastObject.stackedPosition);
+            const v2 = this.object.stackedPosition.subtract(lastCursorPosition);
             const dot = v1.dot(v2);
             const det = v1.x * v2.y - v1.y * v2.x;
             this.angle = Math.abs(Math.atan2(det, dot));
@@ -427,7 +426,7 @@ class DifficultyHitObject {
         }
         if (this.mode === osuBase.Modes.droid) {
             // Temporary lazy end position until a real result can be derived.
-            this.lazyEndPosition = this.object.getStackedPosition(this.mode);
+            this.lazyEndPosition = this.object.stackedPosition;
             // 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(this.object.startTime, this.object.endTime)) {
@@ -443,16 +442,12 @@ class DifficultyHitObject {
             endTimeMin %= 1;
         }
         // Temporary lazy end position until a real result can be derived.
-        this.lazyEndPosition = this.object
-            .getStackedPosition(this.mode)
-            .add(this.object.path.positionAt(endTimeMin));
-        let currentCursorPosition = this.object.getStackedPosition(this.mode);
+        this.lazyEndPosition = this.object.stackedPosition.add(this.object.path.positionAt(endTimeMin));
+        let currentCursorPosition = this.object.stackedPosition;
         const scalingFactor = DifficultyHitObject.normalizedRadius / this.object.radius;
         for (let i = 1; i < nestedObjects.length; ++i) {
             const currentMovementObject = nestedObjects[i];
-            let currentMovement = currentMovementObject
-                .getStackedPosition(this.mode)
-                .subtract(currentCursorPosition);
+            let currentMovement = currentMovementObject.stackedPosition.subtract(currentCursorPosition);
             let currentMovementLength = scalingFactor * currentMovement.length;
             // The amount of movement required so that the cursor position needs to be updated.
             let requiredMovement = this.assumedSliderRadius;
@@ -488,7 +483,7 @@ class DifficultyHitObject {
     }
     getEndCursorPosition(object) {
         var _a;
-        return ((_a = object.lazyEndPosition) !== null && _a !== void 0 ? _a : object.object.getStackedPosition(this.mode));
+        return (_a = object.lazyEndPosition) !== null && _a !== void 0 ? _a : object.object.stackedPosition;
     }
 }
 /**
@@ -616,8 +611,8 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
             return true;
         }
         const distanceThreshold = 2 * this.object.radius;
-        const startPosition = this.object.getStackedPosition(osuBase.Modes.droid);
-        const prevStartPosition = prev.object.getStackedPosition(osuBase.Modes.droid);
+        const startPosition = this.object.stackedPosition;
+        const prevStartPosition = prev.object.stackedPosition;
         // We need to consider two cases:
         //
         // Case 1: Current object is a circle, or previous object is a circle.
@@ -634,7 +629,7 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
         }
         // Check if all nested hitobjects can be hit together.
         for (let i = 1; i < this.object.nestedHitObjects.length; ++i) {
-            const position = this.object.nestedHitObjects[i].getStackedPosition(osuBase.Modes.droid);
+            const position = this.object.nestedHitObjects[i].stackedPosition;
             const prevPosition = prevStartPosition.add(prev.object.curvePositionAt(i / (this.object.nestedHitObjects.length - 1)));
             if (position.getDistance(prevPosition) > distanceThreshold) {
                 return false;
@@ -642,7 +637,7 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
         }
         // Do the same for the previous slider as well.
         for (let i = 1; i < prev.object.nestedHitObjects.length; ++i) {
-            const prevPosition = prev.object.nestedHitObjects[i].getStackedPosition(osuBase.Modes.droid);
+            const prevPosition = prev.object.nestedHitObjects[i].stackedPosition;
             const position = startPosition.add(this.object.curvePositionAt(i / (prev.object.nestedHitObjects.length - 1)));
             if (prevPosition.getDistance(position) > distanceThreshold) {
                 return false;
@@ -680,16 +675,12 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
             prevVisibleObjects.push(prev.object);
         }
         for (const hitObject of prevVisibleObjects) {
-            const distance = this.object
-                .getStackedPosition(this.mode)
-                .getDistance(hitObject.getStackedEndPosition(this.mode));
+            const distance = this.object.stackedPosition.getDistance(hitObject.stackedEndPosition);
             const deltaTime = this.startTime - hitObject.endTime / clockRate;
             this.applyToOverlappingFactor(distance, deltaTime);
         }
         for (const hitObject of nextVisibleObjects) {
-            const distance = hitObject
-                .getStackedPosition(this.mode)
-                .getDistance(this.object.getStackedEndPosition(this.mode));
+            const distance = hitObject.stackedPosition.getDistance(this.object.stackedEndPosition);
             const deltaTime = hitObject.startTime / clockRate - this.endTime;
             if (deltaTime >= 0) {
                 this.noteDensity += 1 - deltaTime / this.timePreempt;
@@ -1157,9 +1148,7 @@ class DroidFlashlightEvaluator {
             if (!(currentObject.object instanceof osuBase.Spinner) &&
                 // Exclude overlapping objects that can be tapped at once.
                 !currentObject.isOverlapping(false)) {
-                const jumpDistance = current.object
-                    .getStackedPosition(osuBase.Modes.droid)
-                    .subtract(currentObject.object.getStackedEndPosition(osuBase.Modes.droid)).length;
+                const jumpDistance = current.object.stackedPosition.subtract(currentObject.object.stackedEndPosition).length;
                 // We want to nerf objects that can be easily seen within the Flashlight circle radius.
                 if (i === 0) {
                     smallDistNerf = Math.min(1, jumpDistance / 75);
@@ -1807,7 +1796,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     constructor() {
         super();
         this.difficultyMultiplier = 0.18;
-        this.difficultyAdjustmentMods.push(osuBase.ModPrecise, osuBase.ModScoreV2, osuBase.ModTraceable);
+        this.difficultyAdjustmentMods.push(osuBase.ModPrecise, osuBase.ModScoreV2, osuBase.ModTraceable, osuBase.ModReplayV6);
     }
     retainDifficultyAdjustmentMods(mods) {
         return mods.filter((mod) => mod.isApplicableToDroid() &&
@@ -2144,10 +2133,7 @@ class PerformanceCalculator {
      * @param options Options for performance calculation.
      */
     handleOptions(options) {
-        var _a;
-        const maxCombo = this.difficultyAttributes.maxCombo;
-        const miss = this.computedAccuracy.nmiss;
-        const combo = (_a = options === null || options === void 0 ? void 0 : options.combo) !== null && _a !== void 0 ? _a : maxCombo - miss;
+        var _a, _b;
         if ((options === null || options === void 0 ? void 0 : options.accPercent) instanceof osuBase.Accuracy) {
             // Copy into new instance to not modify the original
             this.computedAccuracy = new osuBase.Accuracy(options.accPercent);
@@ -2165,9 +2151,12 @@ class PerformanceCalculator {
             this.computedAccuracy = new osuBase.Accuracy({
                 percent: options === null || options === void 0 ? void 0 : options.accPercent,
                 nobjects: this.totalHits,
-                nmiss: (options === null || options === void 0 ? void 0 : options.miss) || 0,
+                nmiss: (_a = options === null || options === void 0 ? void 0 : options.miss) !== null && _a !== void 0 ? _a : 0,
             });
         }
+        const maxCombo = this.difficultyAttributes.maxCombo;
+        const miss = this.computedAccuracy.nmiss;
+        const combo = (_b = options === null || options === void 0 ? void 0 : options.combo) !== null && _b !== void 0 ? _b : maxCombo - miss;
         this.effectiveMissCount = this.calculateEffectiveMissCount(combo, maxCombo);
         if (this.mods.has(osuBase.ModNoFail)) {
             this.finalMultiplier *= Math.max(0.9, 1 - 0.02 * this.effectiveMissCount);
@@ -3099,9 +3088,7 @@ class OsuFlashlightEvaluator {
             const currentObject = current.previous(i);
             cumulativeStrainTime += last.strainTime;
             if (!(currentObject.object instanceof osuBase.Spinner)) {
-                const jumpDistance = current.object
-                    .getStackedPosition(osuBase.Modes.osu)
-                    .subtract(currentObject.object.getStackedEndPosition(osuBase.Modes.osu)).length;
+                const jumpDistance = current.object.stackedPosition.subtract(currentObject.object.stackedEndPosition).length;
                 // We want to nerf objects that can be easily seen within the Flashlight circle radius.
                 if (i === 0) {
                     smallDistNerf = Math.min(1, jumpDistance / 75);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.66",
+    "version": "4.0.0-beta.69",
     "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.66"
+        "@rian8337/osu-base": "^4.0.0-beta.69"
     },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "6791c186a09792996f2b58180a7c0fee5d52a8d6"
+    "gitHead": "aed764bcd1c55a0a937b8f7439146c00b0457bfb"
 }