@rian8337/osu-base 1.0.0

package/dist/beatmap/Parser.js

@@ -0,0 +1,620 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const Beatmap_1 = require("./Beatmap");
+const TimingControlPoint_1 = require("./timings/TimingControlPoint");
+const DifficultyControlPoint_1 = require("./timings/DifficultyControlPoint");
+const BreakPoint_1 = require("./timings/BreakPoint");
+const Circle_1 = require("./hitobjects/Circle");
+const Slider_1 = require("./hitobjects/Slider");
+const Spinner_1 = require("./hitobjects/Spinner");
+const PathType_1 = require("../constants/PathType");
+const Precision_1 = require("../utils/Precision");
+const objectTypes_1 = require("../constants/objectTypes");
+const Vector2_1 = require("../mathutil/Vector2");
+const SliderPath_1 = require("../utils/SliderPath");
+const MapStats_1 = require("../utils/MapStats");
+const MathUtils_1 = require("../mathutil/MathUtils");
+const ParserConstants_1 = require("../constants/ParserConstants");
+/**
+ * A beatmap parser with just enough data for pp calculation.
+ */
+class Parser {
+    constructor() {
+        /**
+         * The parsed beatmap.
+         */
+        this.map = new Beatmap_1.Beatmap();
+        /**
+         * The amount of lines of `.osu` file.
+         */
+        this.line = 0;
+        /**
+         * The currently processed line.
+         */
+        this.currentLine = "";
+        /**
+         * The previously processed line.
+         */
+        this.lastPosition = "";
+        /**
+         * The currently processed section.
+         */
+        this.section = "";
+    }
+    /**
+     * Parses a beatmap.
+     *
+     * This will process a `.osu` file and returns the current instance of the parser for easy chaining.
+     *
+     * @param str The `.osu` file to parse.
+     * @param mods The mods to parse the beatmap for.
+     */
+    parse(str, mods = []) {
+        const lines = str.split("\n");
+        for (let i = 0; i < lines.length; ++i) {
+            this.processLine(lines[i]);
+        }
+        // Objects may be out of order *only* if a user has manually edited an .osu file.
+        // Unfortunately there are "ranked" maps in this state (example: https://osu.ppy.sh/s/594828).
+        // Sort is used to guarantee that the parsing order of hitobjects with equal start times is maintained (stably-sorted).
+        this.map.objects.sort((a, b) => {
+            return a.startTime - b.startTime;
+        });
+        if (this.map.formatVersion >= 6) {
+            this.applyStacking(0, this.map.objects.length - 1);
+        }
+        else {
+            this.applyStackingOld();
+        }
+        const circleSize = new MapStats_1.MapStats({
+            cs: this.map.cs,
+            mods,
+        }).calculate().cs;
+        const scale = (1 - (0.7 * (circleSize - 5)) / 5) / 2;
+        this.map.objects.forEach((h) => {
+            h.scale = scale;
+            if (h instanceof Slider_1.Slider) {
+                h.nestedHitObjects.forEach((n) => {
+                    n.scale = scale;
+                });
+            }
+        });
+        return this;
+    }
+    /**
+     * Logs the line at which an exception occurs.
+     */
+    logError() {
+        return ("at line " +
+            this.line +
+            "\n" +
+            this.currentLine +
+            "\n" +
+            "-> " +
+            this.lastPosition +
+            " <-");
+    }
+    /**
+     * Processes a line of the file.
+     */
+    processLine(line) {
+        this.currentLine = this.lastPosition = line;
+        ++this.line;
+        // comments
+        if (line.startsWith(" ") || line.startsWith("_")) {
+            return this;
+        }
+        // now that we've handled space comments we can trim space
+        line = this.currentLine = line.trim();
+        // c++ style comments
+        if (line.startsWith("//")) {
+            return this;
+        }
+        // [SectionName]
+        if (line.startsWith("[")) {
+            if (this.section === "Difficulty" && !this.map.ar) {
+                this.map.ar = this.map.od;
+            }
+            this.section = line.substring(1, line.length - 1);
+            return this;
+        }
+        if (!line) {
+            return this;
+        }
+        switch (this.section) {
+            case "General":
+                this.general();
+                break;
+            case "Metadata":
+                this.metadata();
+                break;
+            case "Difficulty":
+                this.difficulty();
+                break;
+            case "Events":
+                this.events();
+                break;
+            case "TimingPoints":
+                this.timingPoints();
+                break;
+            case "HitObjects":
+                // Need to check if the beatmap doesn't have an uninherited timing point.
+                // This exists in cases such as /b/2290233 where the beatmap has been
+                // edited by the user.
+                //
+                // In lazer, the default BPM is set to 60 (60000 / 1000).
+                if (this.map.timingPoints.length === 0) {
+                    this.map.timingPoints.push(new TimingControlPoint_1.TimingControlPoint({
+                        time: Number.NEGATIVE_INFINITY,
+                        msPerBeat: 1000,
+                    }));
+                }
+                this.objects();
+                break;
+            default: {
+                const fmtpos = line.indexOf("file format v");
+                if (fmtpos < 0) {
+                    break;
+                }
+                this.map.formatVersion = parseInt(line.substring(fmtpos + 13));
+                break;
+            }
+        }
+        return this;
+    }
+    /**
+     * Sets the last position of the current parser state.
+     *
+     * This is useful to debug syntax errors.
+     */
+    setPosition(str) {
+        this.lastPosition = str.trim();
+        return this.lastPosition;
+    }
+    /**
+     * Logs any syntax errors into the console.
+     */
+    warn(message) {
+        console.warn(message);
+        console.warn(this.logError());
+    }
+    /**
+     * Processes a property of the beatmap. This takes the current line as parameter.
+     *
+     * For example, `ApproachRate:9` will be split into `[ApproachRate, 9]`.
+     */
+    property() {
+        const s = this.currentLine.split(":");
+        s[0] = this.setPosition(s[0]);
+        s[1] = this.setPosition(s.slice(1).join(":"));
+        return s;
+    }
+    /**
+     * Processes the general section of a beatmap.
+     */
+    general() {
+        const p = this.property();
+        if (p[0] === "StackLeniency") {
+            this.map.stackLeniency = parseFloat(p[1]);
+        }
+    }
+    /**
+     * Processes the metadata section of a beatmap.
+     */
+    metadata() {
+        const p = this.property();
+        switch (p[0]) {
+            case "Title":
+                this.map.title = p[1];
+                break;
+            case "TitleUnicode":
+                this.map.titleUnicode = p[1];
+                break;
+            case "Artist":
+                this.map.artist = p[1];
+                break;
+            case "ArtistUnicode":
+                this.map.artistUnicode = p[1];
+                break;
+            case "Creator":
+                this.map.creator = p[1];
+                break;
+            case "Version":
+                this.map.version = p[1];
+                break;
+            case "BeatmapID":
+                this.map.beatmapId = parseInt(p[1]);
+                break;
+            case "BeatmapSetID":
+                this.map.beatmapSetId = parseInt(p[1]);
+                break;
+        }
+    }
+    /**
+     * Processes the events section of a beatmap.
+     */
+    events() {
+        const s = this.currentLine.split(",");
+        if (s[0] !== "2" && s[0] !== "Break")
+            return;
+        this.map.breakPoints.push(new BreakPoint_1.BreakPoint({
+            startTime: parseInt(this.setPosition(s[1])),
+            endTime: parseInt(this.setPosition(s[2])),
+        }));
+    }
+    /**
+     * Processes the difficulty section of a beatmap.
+     */
+    difficulty() {
+        const p = this.property();
+        switch (p[0]) {
+            case "CircleSize":
+                this.map.cs = parseFloat(this.setPosition(p[1]));
+                break;
+            case "OverallDifficulty":
+                this.map.od = parseFloat(this.setPosition(p[1]));
+                break;
+            case "ApproachRate":
+                this.map.ar = parseFloat(this.setPosition(p[1]));
+                break;
+            case "HPDrainRate":
+                this.map.hp = parseFloat(this.setPosition(p[1]));
+                break;
+            case "SliderMultiplier":
+                this.map.sv = parseFloat(this.setPosition(p[1]));
+                break;
+            case "SliderTickRate":
+                this.map.tickRate = parseFloat(this.setPosition(p[1]));
+        }
+    }
+    /**
+     * Processes the timing points section of a beatmap.
+     */
+    timingPoints() {
+        const s = this.currentLine.split(",");
+        if (s.length > 8) {
+            this.warn("Timing point with trailing values");
+        }
+        else if (s.length < 2) {
+            return this.warn("Ignoring malformed timing point");
+        }
+        const time = this.map.getOffsetTime(parseFloat(this.setPosition(s[0])));
+        if (!this.isNumberValid(time)) {
+            return this.warn("Ignoring malformed timing point: Value is invalid, too low, or too high");
+        }
+        const msPerBeat = parseFloat(this.setPosition(s[1]));
+        if (!this.isNumberValid(msPerBeat)) {
+            return this.warn("Ignoring malformed timing point: Value is invalid, too low, or too high");
+        }
+        const speedMultiplier = msPerBeat < 0 ? 100 / -msPerBeat : 1;
+        if (msPerBeat >= 0) {
+            this.map.timingPoints.push(new TimingControlPoint_1.TimingControlPoint({
+                time: time,
+                msPerBeat: msPerBeat,
+            }));
+        }
+        // Remove the last difficulty control point if another difficulty control point overrides it at the same time.
+        if (this.map.difficultyTimingPoints.at(-1)?.time === time) {
+            this.map.difficultyTimingPoints.pop();
+        }
+        this.map.difficultyTimingPoints.push(new DifficultyControlPoint_1.DifficultyControlPoint({
+            time: time,
+            speedMultiplier: speedMultiplier,
+        }));
+    }
+    /**
+     * Processes the objects section of a beatmap.
+     */
+    objects() {
+        const s = this.currentLine.split(",");
+        if (s.length > 11) {
+            this.warn("Object with trailing values");
+        }
+        else if (s.length < 4) {
+            return this.warn("Ignoring malformed hitobject");
+        }
+        const time = this.map.getOffsetTime(parseFloat(this.setPosition(s[2])));
+        const type = parseInt(this.setPosition(s[3]));
+        if (!this.isNumberValid(time) || isNaN(type)) {
+            return this.warn("Ignoring malformed hitobject: Value is invalid, too low, or too high");
+        }
+        const position = new Vector2_1.Vector2(parseFloat(this.setPosition(s[0])), parseFloat(this.setPosition(s[1])));
+        if (!this.isVectorValid(position)) {
+            return this.warn("Ignoring malformed hitobject: Value is invalid, too low, or too high");
+        }
+        if (type & objectTypes_1.objectTypes.circle) {
+            const object = new Circle_1.Circle({
+                startTime: time,
+                type: type,
+                position: position,
+            });
+            ++this.map.circles;
+            this.map.objects.push(object);
+        }
+        else if (type & objectTypes_1.objectTypes.slider) {
+            if (s.length < 8) {
+                return this.warn("Ignoring malformed slider");
+            }
+            const repetitions = Math.max(parseInt(this.setPosition(s[6])), ParserConstants_1.ParserConstants.MIN_REPETITIONS_VALUE);
+            if (!this.isNumberValid(repetitions, 0, ParserConstants_1.ParserConstants.MAX_REPETITIONS_VALUE)) {
+                return this.warn("Ignoring malformed slider: Value is invalid, too low, or too high");
+            }
+            const distance = Math.max(0, parseFloat(this.setPosition(s[7])));
+            if (!this.isNumberValid(distance, 0, ParserConstants_1.ParserConstants.MAX_COORDINATE_VALUE)) {
+                return this.warn("Ignoring malformed slider: Value is invalid, too low, or too high");
+            }
+            const speedMultiplierTimingPoint = this.map.difficultyControlPointAt(time);
+            const msPerBeatTimingPoint = this.map.timingControlPointAt(time);
+            const points = [new Vector2_1.Vector2(0, 0)];
+            const pointSplit = this.setPosition(s[5]).split("|");
+            let pathType = this.convertPathType(pointSplit.shift());
+            for (const point of pointSplit) {
+                const temp = point.split(":");
+                const vec = new Vector2_1.Vector2(+temp[0], +temp[1]);
+                if (!this.isVectorValid(vec)) {
+                    return this.warn("Ignoring malformed slider: Value is invalid, too low, or too high");
+                }
+                points.push(vec.subtract(position));
+            }
+            // A special case for old beatmaps where the first
+            // control point is in the position of the slider.
+            if (points[0].equals(points[1])) {
+                points.shift();
+            }
+            // Edge-case rules (to match stable).
+            if (pathType === PathType_1.PathType.PerfectCurve) {
+                if (points.length !== 3) {
+                    pathType = PathType_1.PathType.Bezier;
+                }
+                else if (Precision_1.Precision.almostEqualsNumber(0, (points[1].y - points[0].y) *
+                    (points[2].x - points[0].x) -
+                    (points[1].x - points[0].x) *
+                        (points[2].y - points[0].y))) {
+                    // osu-stable special-cased colinear perfect curves to a linear path
+                    pathType = PathType_1.PathType.Linear;
+                }
+            }
+            const path = new SliderPath_1.SliderPath({
+                pathType: pathType,
+                controlPoints: points,
+                expectedDistance: distance,
+            });
+            const object = new Slider_1.Slider({
+                position: position,
+                startTime: time,
+                type: type,
+                repetitions: repetitions,
+                path: path,
+                speedMultiplier: MathUtils_1.MathUtils.clamp(speedMultiplierTimingPoint.speedMultiplier, ParserConstants_1.ParserConstants.MIN_SPEEDMULTIPLIER_VALUE, ParserConstants_1.ParserConstants.MAX_SPEEDMULTIPLIER_VALUE),
+                msPerBeat: msPerBeatTimingPoint.msPerBeat,
+                mapSliderVelocity: this.map.sv,
+                mapTickRate: this.map.tickRate,
+                // Prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
+                // This results in more (or less) ticks being generated in <v8 maps for the same time duration.
+                //
+                // This additional check is used in case BPM goes very low or very high.
+                // When lazer is final, this should be revisited.
+                tickDistanceMultiplier: this.isNumberValid(msPerBeatTimingPoint.msPerBeat, ParserConstants_1.ParserConstants.MIN_MSPERBEAT_VALUE, ParserConstants_1.ParserConstants.MAX_MSPERBEAT_VALUE)
+                    ? this.map.formatVersion < 8
+                        ? 1 / speedMultiplierTimingPoint.speedMultiplier
+                        : 1
+                    : 0,
+            });
+            ++this.map.sliders;
+            this.map.objects.push(object);
+        }
+        else if (type & objectTypes_1.objectTypes.spinner) {
+            const object = new Spinner_1.Spinner({
+                startTime: time,
+                type: type,
+                duration: parseInt(this.setPosition(s[5])) - time,
+            });
+            if (!this.isNumberValid(object.duration)) {
+                return this.warn("Ignoring malformed spinner: Value is invalid, too low, or too high");
+            }
+            ++this.map.spinners;
+            this.map.objects.push(object);
+        }
+    }
+    /**
+     * Converts string slider path to a `PathType`.
+     */
+    convertPathType(input) {
+        switch (input) {
+            case "B":
+                return PathType_1.PathType.Bezier;
+            case "L":
+                return PathType_1.PathType.Linear;
+            case "P":
+                return PathType_1.PathType.PerfectCurve;
+            default:
+                return PathType_1.PathType.Catmull;
+        }
+    }
+    /**
+     * Applies stacking to hitobjects for beatmap version 6 or above.
+     */
+    applyStacking(startIndex, endIndex) {
+        const stackDistance = 3;
+        let timePreempt = 600;
+        const ar = this.map.ar;
+        if (ar > 5) {
+            timePreempt = 1200 + ((450 - 1200) * (ar - 5)) / 5;
+        }
+        else if (ar < 5) {
+            timePreempt = 1200 - ((1200 - 1800) * (5 - ar)) / 5;
+        }
+        else {
+            timePreempt = 1200;
+        }
+        let extendedEndIndex = endIndex;
+        const stackThreshold = timePreempt * this.map.stackLeniency;
+        if (endIndex < this.map.objects.length - 1) {
+            for (let i = endIndex; i >= startIndex; --i) {
+                let stackBaseIndex = i;
+                for (let n = stackBaseIndex + 1; n < this.map.objects.length; ++n) {
+                    const stackBaseObject = this.map.objects[stackBaseIndex];
+                    if (stackBaseObject instanceof Spinner_1.Spinner) {
+                        break;
+                    }
+                    const objectN = this.map.objects[n];
+                    if (objectN instanceof Spinner_1.Spinner) {
+                        break;
+                    }
+                    const endTime = stackBaseObject.endTime;
+                    if (objectN.startTime - endTime > stackThreshold) {
+                        break;
+                    }
+                    const endPositionDistanceCheck = stackBaseObject instanceof Slider_1.Slider
+                        ? stackBaseObject.endPosition.getDistance(objectN.position) < stackDistance
+                        : false;
+                    if (stackBaseObject.position.getDistance(objectN.position) <
+                        stackDistance ||
+                        endPositionDistanceCheck) {
+                        stackBaseIndex = n;
+                        objectN.stackHeight = 0;
+                    }
+                }
+                if (stackBaseIndex > extendedEndIndex) {
+                    extendedEndIndex = stackBaseIndex;
+                    if (extendedEndIndex === this.map.objects.length - 1) {
+                        break;
+                    }
+                }
+            }
+        }
+        let extendedStartIndex = startIndex;
+        for (let i = extendedEndIndex; i > startIndex; --i) {
+            let n = i;
+            let objectI = this.map.objects[i];
+            if (objectI.stackHeight !== 0 ||
+                objectI.type & objectTypes_1.objectTypes.spinner) {
+                continue;
+            }
+            if (objectI.type & objectTypes_1.objectTypes.circle) {
+                while (--n >= 0) {
+                    const objectN = this.map.objects[n];
+                    if (objectN instanceof Spinner_1.Spinner) {
+                        continue;
+                    }
+                    const endTime = objectN.endTime;
+                    if (objectI.startTime - endTime > stackThreshold) {
+                        break;
+                    }
+                    if (n < extendedStartIndex) {
+                        objectN.stackHeight = 0;
+                        extendedStartIndex = n;
+                    }
+                    const endPositionDistanceCheck = objectN instanceof Slider_1.Slider
+                        ? objectN.endPosition.getDistance(objectI.position) < stackDistance
+                        : false;
+                    if (endPositionDistanceCheck) {
+                        const offset = objectI.stackHeight - objectN.stackHeight + 1;
+                        for (let j = n + 1; j <= i; ++j) {
+                            const objectJ = this.map.objects[j];
+                            if (objectN.endPosition.getDistance(objectJ.position) < stackDistance) {
+                                objectJ.stackHeight -= offset;
+                            }
+                        }
+                        break;
+                    }
+                    if (objectN.position.getDistance(objectI.position) <
+                        stackDistance) {
+                        objectN.stackHeight = objectI.stackHeight + 1;
+                        objectI = objectN;
+                    }
+                }
+            }
+            else if (objectI instanceof Slider_1.Slider) {
+                while (--n >= startIndex) {
+                    const objectN = this.map.objects[n];
+                    if (objectN instanceof Spinner_1.Spinner) {
+                        continue;
+                    }
+                    if (objectI.startTime - objectN.startTime >
+                        stackThreshold) {
+                        break;
+                    }
+                    const objectNEndPosition = objectN instanceof Circle_1.Circle
+                        ? objectN.position
+                        : objectN.endPosition;
+                    if (objectNEndPosition.getDistance(objectI.position) <
+                        stackDistance) {
+                        objectN.stackHeight = objectI.stackHeight + 1;
+                        objectI = objectN;
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Applies stacking to hitobjects for beatmap version 5 or below.
+     */
+    applyStackingOld() {
+        const stackDistance = 3;
+        let timePreempt = 600;
+        const ar = this.map.ar;
+        if (ar > 5) {
+            timePreempt = 1200 + ((450 - 1200) * (ar - 5)) / 5;
+        }
+        else if (ar < 5) {
+            timePreempt = 1200 - ((1200 - 1800) * (5 - ar)) / 5;
+        }
+        else {
+            timePreempt = 1200;
+        }
+        for (let i = 0; i < this.map.objects.length; ++i) {
+            const currentObject = this.map.objects[i];
+            if (currentObject.stackHeight !== 0 &&
+                !(currentObject instanceof Slider_1.Slider)) {
+                continue;
+            }
+            let startTime = currentObject.endTime;
+            let sliderStack = 0;
+            for (let j = i + 1; j < this.map.objects.length; ++j) {
+                const stackThreshold = timePreempt * this.map.stackLeniency;
+                if (this.map.objects[j].startTime - stackThreshold >
+                    startTime) {
+                    break;
+                }
+                // The start position of the hitobject, or the position at the end of the path if the hitobject is a slider
+                const position2 = currentObject instanceof Slider_1.Slider
+                    ? currentObject.endPosition
+                    : currentObject.position;
+                if (this.map.objects[j].position.getDistance(currentObject.position) < stackDistance) {
+                    ++currentObject.stackHeight;
+                    startTime = this.map.objects[j].endTime;
+                }
+                else if (this.map.objects[j].position.getDistance(position2) <
+                    stackDistance) {
+                    // Case for sliders - bump notes down and right, rather than up and left.
+                    ++sliderStack;
+                    this.map.objects[j].stackHeight -= sliderStack;
+                    startTime = this.map.objects[j].endTime;
+                }
+            }
+        }
+    }
+    /**
+     * Checks if a number is within a given threshold.
+     *
+     * @param num The number to check.
+     * @param min The minimum threshold. Defaults to `-ParserConstants.MAX_PARSE_VALUE`.
+     * @param max The maximum threshold. Defaults to `ParserConstants.MAX_PARSE_VALUE`.
+     */
+    isNumberValid(num, min = -ParserConstants_1.ParserConstants.MAX_PARSE_VALUE, max = ParserConstants_1.ParserConstants.MAX_PARSE_VALUE) {
+        return num >= min && num <= max;
+    }
+    /**
+     * Checks if each coordinates of a vector is within a given threshold.
+     *
+     * @param vec The vector to check.
+     * @param limit The threshold. Defaults to `ParserConstants.MAX_COORDINATE_VALUE`.
+     */
+    isVectorValid(vec, min = -ParserConstants_1.ParserConstants.MAX_COORDINATE_VALUE, max = ParserConstants_1.ParserConstants.MAX_COORDINATE_VALUE) {
+        return (this.isNumberValid(vec.x, min, max) &&
+            this.isNumberValid(vec.y, min, max));
+    }
+}
+exports.Parser = Parser;

package/dist/beatmap/hitobjects/Circle.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Circle = void 0;
+const HitObject_1 = require("./HitObject");
+/**
+ * Represents a circle in a beatmap.
+ *
+ * All we need from circles is their position. All positions
+ * stored in the objects are in playfield coordinates (512*384
+ * rectangle).
+ */
+class Circle extends HitObject_1.HitObject {
+    constructor(values) {
+        super(values);
+    }
+    toString() {
+        return `Position: [${this.position.x}, ${this.position.y}]`;
+    }
+}
+exports.Circle = Circle;