@rian8337/osu-difficulty-calculator 1.0.0

package/dist/base/StrainSkill.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrainSkill = void 0;
+const Skill_1 = require("./Skill");
+/**
+ * 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 StrainSkill extends Skill_1.Skill {
+    constructor() {
+        super(...arguments);
+        /**
+         * The strain of currently calculated hitobject.
+         */
+        this.currentStrain = 0;
+        /**
+         * The current section's strain peak.
+         */
+        this.currentSectionPeak = 0;
+        /**
+         * Strain peaks are stored here.
+         */
+        this.strainPeaks = [];
+        this.sectionLength = 400;
+        this.currentSectionEnd = 0;
+    }
+    /**
+     * Calculates the strain value of a hitobject and stores the value in it. This value is affected by previously processed objects.
+     *
+     * @param current The hitobject to process.
+     */
+    process(current) {
+        // The first object doesn't generate a strain, so we begin with an incremented section end
+        if (this.previous.length === 0) {
+            this.currentSectionEnd =
+                Math.ceil(current.startTime / this.sectionLength) *
+                    this.sectionLength;
+        }
+        while (current.startTime > this.currentSectionEnd) {
+            this.saveCurrentPeak();
+            this.startNewSectionFrom(this.currentSectionEnd);
+            this.currentSectionEnd += this.sectionLength;
+        }
+        this.currentStrain = this.strainValueAt(current);
+        this.saveToHitObject(current);
+        this.currentSectionPeak = Math.max(this.currentStrain, this.currentSectionPeak);
+    }
+    /**
+     * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
+     */
+    saveCurrentPeak() {
+        this.strainPeaks.push(this.currentSectionPeak);
+    }
+    /**
+     * Sets the initial strain level for a new section.
+     *
+     * @param offset The beginning of the new section in milliseconds, adjusted by speed multiplier.
+     */
+    startNewSectionFrom(offset) {
+        // The maximum strain of the new section is not zero by default, strain decays as usual regardless of section boundaries.
+        // This means we need to capture the strain level at the beginning of the new section, and use that as the initial peak level.
+        this.currentSectionPeak =
+            this.currentStrain *
+                this.strainDecay(offset - this.previous[0].startTime);
+    }
+    /**
+     * Calculates strain decay for a specified time frame.
+     *
+     * @param ms The time frame to calculate.
+     */
+    strainDecay(ms) {
+        return Math.pow(this.strainDecayBase, ms / 1000);
+    }
+}
+exports.StrainSkill = StrainSkill;

package/dist/index.js

@@ -0,0 +1,25 @@
+"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("./preprocessing/DifficultyHitObject"), exports);
+__exportStar(require("./preprocessing/DifficultyHitObjectCreator"), exports);
+__exportStar(require("./skills/DroidAim"), exports);
+__exportStar(require("./skills/DroidFlashlight"), exports);
+__exportStar(require("./DroidPerformanceCalculator"), exports);
+__exportStar(require("./DroidStarRating"), exports);
+__exportStar(require("./skills/DroidTap"), exports);
+__exportStar(require("./MapStars"), exports);
+__exportStar(require("./skills/OsuAim"), exports);
+__exportStar(require("./skills/OsuFlashlight"), exports);
+__exportStar(require("./OsuPerformanceCalculator"), exports);
+__exportStar(require("./skills/OsuSpeed"), exports);
+__exportStar(require("./OsuStarRating"), exports);

package/dist/preprocessing/DifficultyHitObject.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DifficultyHitObject = void 0;
+/**
+ * Represents an osu!standard hit object with difficulty calculation values.
+ */
+class DifficultyHitObject {
+    /**
+     * @param object The underlying hitobject.
+     */
+    constructor(object) {
+        /**
+         * The aim strain generated by the hitobject if sliders are considered.
+         */
+        this.aimStrainWithSliders = 0;
+        /**
+         * The aim strain generated by the hitobject if sliders are not considered.
+         */
+        this.aimStrainWithoutSliders = 0;
+        /**
+         * The tap strain generated by the hitobject.
+         */
+        this.tapStrain = 0;
+        /**
+         * The tap strain generated by the hitobject if `strainTime` isn't modified by
+         * OD. This is used in three-finger detection.
+         */
+        this.originalTapStrain = 0;
+        /**
+         * The rhythm multiplier generated by the hitobject.
+         */
+        this.rhythmMultiplier = 0;
+        /**
+         * The flashlight strain generated by the hitobject.
+         */
+        this.flashlightStrain = 0;
+        /**
+         * The normalized distance from the "lazy" end position of the previous hitobject to the start position of this hitobject.
+         *
+         * The "lazy" end position is the position at which the cursor ends up if the previous hitobject is followed with as minimal movement as possible (i.e. on the edge of slider follow circles).
+         */
+        this.lazyJumpDistance = 0;
+        /**
+         * The normalized shortest distance to consider for a jump between the previous hitobject and this hitobject.
+         *
+         * This is bounded from above by `lazyJumpDistance`, and is smaller than the former if a more natural path is able to be taken through the previous hitobject.
+         *
+         * Suppose a linear slider - circle pattern. Following the slider lazily (see: `lazyJumpDistance`) will result in underestimating the true end position of the slider as being closer towards the start position.
+         * As a result, `lazyJumpDistance` overestimates the jump distance because the player is able to take a more natural path by following through the slider to its end,
+         * such that the jump is felt as only starting from the slider's true end position.
+         *
+         * Now consider a slider - circle pattern where the circle is stacked along the path inside the slider.
+         * In this case, the lazy end position correctly estimates the true end position of the slider and provides the more natural movement path.
+         */
+        this.minimumJumpDistance = 0;
+        /**
+         * The time taken to travel through `minimumJumpDistance`, with a minimum value of 25ms.
+         */
+        this.minimumJumpTime = 0;
+        /**
+         * The normalized distance between the start and end position of this hitobject.
+         */
+        this.travelDistance = 0;
+        /**
+         * The time taken to travel through `travelDistance`, with a minimum value of 25ms for a non-zero distance.
+         */
+        this.travelTime = 0;
+        /**
+         * Angle the player has to take to hit this hitobject.
+         *
+         * Calculated as the angle between the circles (current-2, current-1, current).
+         */
+        this.angle = null;
+        /**
+         * The amount of milliseconds elapsed between this hitobject and the last hitobject.
+         */
+        this.deltaTime = 0;
+        /**
+         * The amount of milliseconds elapsed since the start time of the previous hitobject, with a minimum of 25ms.
+         */
+        this.strainTime = 0;
+        /**
+         * Adjusted start time of the hitobject, taking speed multiplier into account.
+         */
+        this.startTime = 0;
+        this.object = object;
+    }
+}
+exports.DifficultyHitObject = DifficultyHitObject;

package/dist/preprocessing/DifficultyHitObjectCreator.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DifficultyHitObjectCreator = void 0;
+const osu_base_1 = require("@rian8337/osu-base");
+const DifficultyHitObject_1 = require("./DifficultyHitObject");
+/**
+ * A converter used to convert normal hitobjects into difficulty hitobjects.
+ */
+class DifficultyHitObjectCreator {
+    constructor() {
+        /**
+         * The threshold for small circle buff for osu!droid.
+         */
+        this.DROID_CIRCLESIZE_BUFF_THRESHOLD = 52.5;
+        /**
+         * The threshold for small circle buff for osu!standard.
+         */
+        this.PC_CIRCLESIZE_BUFF_THRESHOLD = 30;
+        /**
+         * The gamemode this creator is creating for.
+         */
+        this.mode = osu_base_1.modes.osu;
+        /**
+         * The base normalized radius of hitobjects.
+         */
+        this.normalizedRadius = 50;
+        this.maximumSliderRadius = this.normalizedRadius * 2.4;
+        this.assumedSliderRadius = this.normalizedRadius * 1.8;
+        this.minDeltaTime = 25;
+    }
+    /**
+     * Generates difficulty hitobjects for difficulty calculation.
+     */
+    generateDifficultyObjects(params) {
+        this.mode = params.mode;
+        const circleSize = params.circleSize;
+        const scale = (1 - (0.7 * (circleSize - 5)) / 5) / 2;
+        params.objects[0].scale = scale;
+        const scalingFactor = this.getScalingFactor(params.objects[0].radius);
+        const difficultyObjects = [];
+        for (let i = 0; i < params.objects.length; ++i) {
+            const object = new DifficultyHitObject_1.DifficultyHitObject(params.objects[i]);
+            object.object.scale = scale;
+            if (object.object instanceof osu_base_1.Slider) {
+                object.object.nestedHitObjects.forEach((h) => {
+                    h.scale = scale;
+                });
+                this.calculateSliderCursorPosition(object.object);
+                object.travelDistance = object.object.lazyTravelDistance;
+                object.travelTime = Math.max(object.object.lazyTravelTime / params.speedMultiplier, this.minDeltaTime);
+            }
+            const lastObject = difficultyObjects[i - 1];
+            const lastLastObject = difficultyObjects[i - 2];
+            object.startTime = object.object.startTime / params.speedMultiplier;
+            if (!lastObject) {
+                difficultyObjects.push(object);
+                continue;
+            }
+            object.deltaTime =
+                (object.object.startTime - lastObject.object.startTime) /
+                    params.speedMultiplier;
+            // Cap to 25ms to prevent difficulty calculation breaking from simulatenous objects.
+            object.strainTime = Math.max(this.minDeltaTime, object.deltaTime);
+            if (object.object instanceof osu_base_1.Spinner ||
+                lastObject.object instanceof osu_base_1.Spinner) {
+                difficultyObjects.push(object);
+                continue;
+            }
+            const lastCursorPosition = this.getEndCursorPosition(lastObject.object);
+            object.lazyJumpDistance = object.object.stackedPosition
+                .scale(scalingFactor)
+                .subtract(lastCursorPosition.scale(scalingFactor)).length;
+            object.minimumJumpTime = object.strainTime;
+            object.minimumJumpDistance = object.lazyJumpDistance;
+            if (lastObject.object instanceof osu_base_1.Slider) {
+                object.minimumJumpTime = Math.max(object.strainTime - lastObject.travelTime, this.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.
+                //
+                // 1. The anti-flow pattern, where players cut the slider short in order to move to the next hitobject.
+                //
+                //      <======o==>  ← slider
+                //             |     ← most natural jump path
+                //             o     ← a follow-up hitcircle
+                //
+                // In this case the most natural jump path is approximated by LazyJumpDistance.
+                //
+                // 2. The flow pattern, where players follow through the slider to its visual extent into the next hitobject.
+                //
+                //      <======o==>---o
+                //                  ↑
+                //        most natural jump path
+                //
+                // 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 = lastObject.object.tailCircle.stackedPosition.subtract(object.object.stackedPosition).length * scalingFactor;
+                object.minimumJumpDistance = Math.max(0, Math.min(object.lazyJumpDistance -
+                    (this.maximumSliderRadius -
+                        this.assumedSliderRadius), tailJumpDistance - this.maximumSliderRadius));
+            }
+            if (lastLastObject && !(lastLastObject.object instanceof osu_base_1.Spinner)) {
+                const lastLastCursorPosition = this.getEndCursorPosition(lastLastObject.object);
+                const v1 = lastLastCursorPosition.subtract(lastObject.object.stackedPosition);
+                const v2 = object.object.stackedPosition.subtract(lastCursorPosition);
+                const dot = v1.dot(v2);
+                const det = v1.x * v2.y - v1.y * v2.x;
+                object.angle = Math.abs(Math.atan2(det, dot));
+            }
+            difficultyObjects.push(object);
+        }
+        return difficultyObjects;
+    }
+    /**
+     * Calculates a slider's cursor position.
+     */
+    calculateSliderCursorPosition(slider) {
+        if (slider.lazyEndPosition) {
+            return;
+        }
+        // Droid doesn't have a legacy slider tail. Since beatmap parser defaults slider tail
+        // to legacy slider tail, it needs to be changed to real slider tail first.
+        if (this.mode === osu_base_1.modes.droid) {
+            slider.tailCircle.startTime += osu_base_1.Slider.legacyLastTickOffset;
+            slider.tailCircle.endTime += osu_base_1.Slider.legacyLastTickOffset;
+            slider.nestedHitObjects.sort((a, b) => {
+                return a.startTime - b.startTime;
+            });
+            // Temporary lazy end position until a real result can be derived.
+            slider.lazyEndPosition = slider.stackedPosition;
+            // Stop here if the slider has too short duration due to float number limitation.
+            // Incredibly close start and end time fluctuates travel distance and lazy
+            // end position heavily, which we do not want to happen.
+            //
+            // In the real game, this shouldn't happen. Perhaps we need to reinvestigate this
+            // in the future.
+            if (osu_base_1.Precision.almostEqualsNumber(slider.startTime, slider.endTime)) {
+                return;
+            }
+        }
+        // Not using slider.endTime due to legacy last tick offset.
+        slider.lazyTravelTime =
+            slider.nestedHitObjects.at(-1).startTime - slider.startTime;
+        let endTimeMin = slider.lazyTravelTime / slider.spanDuration;
+        if (endTimeMin % 2 >= 1) {
+            endTimeMin = 1 - (endTimeMin % 1);
+        }
+        else {
+            endTimeMin %= 1;
+        }
+        // Temporary lazy end position until a real result can be derived.
+        slider.lazyEndPosition = slider.stackedPosition.add(slider.path.positionAt(endTimeMin));
+        let currentCursorPosition = slider.stackedPosition;
+        const scalingFactor = this.normalizedRadius / slider.radius;
+        for (let i = 1; i < slider.nestedHitObjects.length; ++i) {
+            const currentMovementObject = slider.nestedHitObjects[i];
+            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;
+            if (i === slider.nestedHitObjects.length - 1) {
+                // The end of a slider has special aim rules due to the relaxed time constraint on position.
+                // 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);
+                if (lazyMovement.length < currentMovement.length) {
+                    currentMovement = lazyMovement;
+                }
+                currentMovementLength = scalingFactor * currentMovement.length;
+            }
+            else if (currentMovementObject instanceof osu_base_1.RepeatPoint) {
+                // For a slider repeat, assume a tighter movement threshold to better assess repeat sliders.
+                requiredMovement = this.normalizedRadius;
+            }
+            if (currentMovementLength > requiredMovement) {
+                // This finds the positional delta from the required radius and the current position,
+                // and updates the currentCursorPosition accordingly, as well as rewarding distance.
+                currentCursorPosition = currentCursorPosition.add(currentMovement.scale((currentMovementLength - requiredMovement) /
+                    currentMovementLength));
+                currentMovementLength *=
+                    (currentMovementLength - requiredMovement) /
+                        currentMovementLength;
+                slider.lazyTravelDistance += currentMovementLength;
+            }
+            if (i === slider.nestedHitObjects.length - 1) {
+                slider.lazyEndPosition = currentCursorPosition;
+            }
+        }
+        // Bonus for repeat sliders until a better per nested object strain system can be achieved.
+        if (this.mode === osu_base_1.modes.droid) {
+            slider.lazyTravelDistance *= Math.pow(1 + slider.repeatPoints / 4, 1 / 4);
+        }
+        else {
+            slider.lazyTravelDistance *= Math.pow(1 + slider.repeatPoints / 2.5, 1 / 2.5);
+        }
+    }
+    /**
+     * Gets the scaling factor of a radius.
+     *
+     * @param radius The radius to get the scaling factor from.
+     */
+    getScalingFactor(radius) {
+        // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
+        let scalingFactor = this.normalizedRadius / radius;
+        // High circle size (small CS) bonus
+        switch (this.mode) {
+            case osu_base_1.modes.droid:
+                if (radius < this.DROID_CIRCLESIZE_BUFF_THRESHOLD) {
+                    scalingFactor *=
+                        1 +
+                            Math.min(this.DROID_CIRCLESIZE_BUFF_THRESHOLD - radius, 20) /
+                                40;
+                }
+                break;
+            case osu_base_1.modes.osu:
+                if (radius < this.PC_CIRCLESIZE_BUFF_THRESHOLD) {
+                    scalingFactor *=
+                        1 +
+                            Math.min(this.PC_CIRCLESIZE_BUFF_THRESHOLD - radius, 5) /
+                                50;
+                }
+        }
+        return scalingFactor;
+    }
+    /**
+     * Returns the end cursor position of a hitobject.
+     */
+    getEndCursorPosition(object) {
+        let pos = object.stackedPosition;
+        if (object instanceof osu_base_1.Slider) {
+            this.calculateSliderCursorPosition(object);
+            pos = object.lazyEndPosition ?? pos;
+        }
+        return pos;
+    }
+}
+exports.DifficultyHitObjectCreator = DifficultyHitObjectCreator;

package/dist/skills/DroidAim.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DroidAim = void 0;
+const osu_base_1 = require("@rian8337/osu-base");
+const DroidSkill_1 = require("./DroidSkill");
+/**
+ * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
+ */
+class DroidAim extends DroidSkill_1.DroidSkill {
+    constructor(mods, withSliders) {
+        super(mods);
+        this.skillMultiplier = 23.25;
+        this.strainDecayBase = 0.15;
+        this.reducedSectionCount = 10;
+        this.reducedSectionBaseline = 0.75;
+        this.starsPerDouble = 1.05;
+        /**
+         * Spacing threshold for a single hitobject spacing.
+         */
+        this.SINGLE_SPACING_THRESHOLD = 175;
+        // ~200 1/2 BPM jumps
+        this.minSpeedBonus = 150;
+        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) {
+            return 0;
+        }
+        return this.aimStrainOf(current) + this.movementStrainOf(current);
+    }
+    /**
+     * Calculates the aim strain of a hitobject.
+     */
+    aimStrainOf(current) {
+        if (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 &&
+            last.object.ticks > 1 &&
+            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 &&
+            lastLast.object.ticks > 1 &&
+            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;
+    }
+    /**
+     * Calculates the movement strain of a hitobject.
+     */
+    movementStrainOf(current) {
+        let speedBonus = 1;
+        if (current.strainTime < this.minSpeedBonus) {
+            speedBonus +=
+                0.75 *
+                    Math.pow((this.minSpeedBonus - current.strainTime) / 45, 2);
+        }
+        const travelDistance = this.previous[0]?.travelDistance ?? 0;
+        const distance = Math.min(this.SINGLE_SPACING_THRESHOLD, travelDistance + current.minimumJumpDistance);
+        return ((50 *
+            speedBonus *
+            Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 5)) /
+            current.strainTime);
+    }
+    /**
+     * @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) {
+        if (this.withSliders) {
+            current.aimStrainWithSliders = this.currentStrain;
+        }
+        else {
+            current.aimStrainWithoutSliders = 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.DroidAim = DroidAim;