@rian8337/osu-base 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Rian8337
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# `osu-base`
+
+> TODO: description
+
+## Usage
+
+```
+const osuBase = require('osu-base');
+
+// TODO: DEMONSTRATE API
+```

package/dist/beatmap/Beatmap.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Beatmap = void 0;
+const Slider_1 = require("./hitobjects/Slider");
+/**
+ * Represents a beatmap with advanced information.
+ */
+class Beatmap {
+    constructor() {
+        /**
+         * The format version of the beatmap.
+         */
+        this.formatVersion = 1;
+        /**
+         * The title of the song of the beatmap.
+         */
+        this.title = "";
+        /**
+         * The unicode title of the song of the beatmap.
+         */
+        this.titleUnicode = "";
+        /**
+         * The artist of the song of the beatmap.
+         */
+        this.artist = "";
+        /**
+         * The unicode artist of the song of the beatmap.
+         */
+        this.artistUnicode = "";
+        /**
+         * The creator of the beatmap.
+         */
+        this.creator = "";
+        /**
+         * The difficulty name of the beatmap.
+         */
+        this.version = "";
+        /**
+         * The circle size of the beatmap.
+         */
+        this.cs = 5;
+        /**
+         * The overall difficulty of the beatmap.
+         */
+        this.od = 5;
+        /**
+         * The health drain rate of the beatmap.
+         */
+        this.hp = 5;
+        /**
+         * The slider velocity of the beatmap.
+         */
+        this.sv = 1;
+        /**
+         * The slider tick rate of the beatmap.
+         */
+        this.tickRate = 1;
+        /**
+         * The amount of circles in the beatmap.
+         */
+        this.circles = 0;
+        /**
+         * The amount of sliders in the beatmap.
+         */
+        this.sliders = 0;
+        /**
+         * The amount of spinners in the beatmap.
+         */
+        this.spinners = 0;
+        /**
+         * The objects of the beatmap.
+         */
+        this.objects = [];
+        /**
+         * The timing points of the beatmap.
+         */
+        this.timingPoints = [];
+        /**
+         * The difficulty timing points of the beatmap.
+         */
+        this.difficultyTimingPoints = [];
+        /**
+         * The break points of the beatmap.
+         */
+        this.breakPoints = [];
+        /**
+         * The stack leniency of the beatmap.
+         */
+        this.stackLeniency = 0.7;
+    }
+    /**
+     * The amount of slider ticks in the beatmap.
+     */
+    get sliderTicks() {
+        const sliders = (this.objects.filter((v) => v instanceof Slider_1.Slider));
+        return sliders
+            .map((v) => v.ticks)
+            .reduce((acc, value) => acc + value, 0);
+    }
+    /**
+     * The amount of sliderends in the beatmap.
+     */
+    get sliderEnds() {
+        return this.sliders;
+    }
+    /**
+     * The amount of slider repeat points in the beatmap.
+     */
+    get sliderRepeatPoints() {
+        const sliders = (this.objects.filter((v) => v instanceof Slider_1.Slider));
+        return sliders
+            .map((v) => v.repeatPoints)
+            .reduce((acc, value) => acc + value, 0);
+    }
+    /**
+     * The maximum combo of the beatmap.
+     */
+    get maxCombo() {
+        return (this.circles +
+            this.sliders +
+            this.sliderTicks +
+            this.sliderRepeatPoints +
+            this.sliderEnds +
+            this.spinners);
+    }
+    /**
+     * Returns a time combined with beatmap-wide time offset.
+     *
+     * BeatmapVersion 4 and lower had an incorrect offset. Stable has this set as 24ms off.
+     *
+     * @param time The time.
+     */
+    getOffsetTime(time) {
+        return time + (this.formatVersion < 5 ? 24 : 0);
+    }
+    /**
+     * Gets the timing control point that applies at a given time.
+     *
+     * @param time The time.
+     */
+    timingControlPointAt(time) {
+        return this.getTimingPoint(time, this.timingPoints);
+    }
+    /**
+     * Gets the difficulty control point that applies at a given time.
+     *
+     * @param time The time.
+     */
+    difficultyControlPointAt(time) {
+        return this.getTimingPoint(time, this.difficultyTimingPoints);
+    }
+    /**
+     * Gets the timing point that applies at a given time.
+     *
+     * @param time The time.
+     * @param list The timing points to search in.
+     */
+    getTimingPoint(time, list) {
+        if (list.length === 0) {
+            throw new Error("No timing points have been loaded");
+        }
+        if (time < list[0].time) {
+            return list[0];
+        }
+        if (time >= list.at(-1).time) {
+            return list.at(-1);
+        }
+        let l = 0;
+        let r = list.length - 2;
+        while (l <= r) {
+            const pivot = l + ((r - l) >> 1);
+            if (list[pivot].time < time) {
+                l = pivot + 1;
+            }
+            else if (list[pivot].time > time) {
+                r = pivot - 1;
+            }
+            else {
+                return list[pivot];
+            }
+        }
+        // l will be the first control point with time > list[l].time, but we want the one before it
+        return list[l - 1];
+    }
+    /**
+     * Returns a string representative of the class.
+     */
+    toString() {
+        let res = this.artist + " - " + this.title + " [";
+        if (this.titleUnicode || this.artistUnicode) {
+            res += "(" + this.artistUnicode + " - " + this.titleUnicode + ")";
+        }
+        res +=
+            this.version +
+                "] mapped by " +
+                this.creator +
+                "\n" +
+                "\n" +
+                "AR" +
+                parseFloat(this.ar.toFixed(2)) +
+                " " +
+                "OD" +
+                parseFloat(this.od.toFixed(2)) +
+                " " +
+                "CS" +
+                parseFloat(this.cs.toFixed(2)) +
+                " " +
+                "HP" +
+                parseFloat(this.hp.toFixed(2)) +
+                "\n" +
+                this.circles +
+                " circles, " +
+                this.sliders +
+                " sliders, " +
+                this.spinners +
+                " spinners" +
+                "\n" +
+                this.maxCombo +
+                " max combo";
+        return res;
+    }
+}
+exports.Beatmap = Beatmap;