nonebot-plugin-osubot 6.23.1__py3-none-any.whl → 6.24.1__py3-none-any.whl

nonebot_plugin_osubot/draw/osu_preview_templates/js/catch/juicestream.js

@@ -0,0 +1,176 @@
+function JuiceStream(data, beatmap)
+{
+    Slider.call(this, data, beatmap);
+
+    var points = data[5].split('|');
+    var sliderType = points[0];
+    points[0] = this.position;
+    for (var i = 1; i < points.length; i++)
+    {
+        points[i] = new Point(points[i].split(':'));
+    }
+    this.repeat = data[6] | 0;
+    this.pixelLength = +data[7];
+
+    this.timingPoint = this.beatmap.timingPointAt(this.time);
+    this.beatLength = this.timingPoint.beatLength;
+    this.timingPointStart = this.timingPoint.time;
+
+    this.sliderTime = this.beatLength * ( this.pixelLength / this.beatmap.SliderMultiplier ) / 100;
+    this.velocityFactor = 100 * this.beatmap.SliderMultiplier / this.beatLength;
+    this.tickDistanceFactor = 100 * this.beatmap.SliderMultiplier / this.beatmap.SliderTickRate;
+    this.velocity = this.velocityFactor * this.timingPoint.sliderVelocity;
+    this.tickDistance = this.tickDistanceFactor * this.timingPoint.sliderVelocity;
+
+    this.endTime = this.time + this.sliderTime * this.repeat;
+    this.duration = this.endTime - this.time;
+
+    this.spanCount = parseInt(this.repeat);
+
+    this.curve = Curve.parse(sliderType, points, this.pixelLength);
+
+    this.endPosition = this.curve.pointAt(1);
+
+    this.max_length = 100000;
+    let length = Math.min(this.max_length, this.pixelLength);
+    this.tickDistance = Math.clamp(this.tickDistance, 0, length);
+    this.minDistanceFromEnd = this.velocity * 10;
+
+    this.events = [];
+    this.events.push({type: "head", time: this.time, pathProgress: 0});
+    if (this.tickDistance != 0) {
+        for (let span = 0; span < this.spanCount; span++) {
+            let spanStartTime = this.time + span * this.sliderTime;
+            let reversed = span % 2 == 1;
+            let ticks = this.generateTicks(span, spanStartTime, this.sliderTime, reversed, length, this.tickDistance, this.minDistanceFromEnd);
+            if (reversed) ticks = ticks.reverse();
+            this.events.push(...ticks);
+            if (span < this.spanCount - 1)
+            {
+                this.events.push({
+                    type: "repeat", 
+                    time: spanStartTime + this.sliderTime,
+                    pathProgress: (span + 1) % 2
+                });
+            }
+        }
+    }
+
+    let legacyLastTickOffset = 36;
+    let finalSpanIndex = this.spanCount - 1;
+    let finalSpanStartTime = this.time + finalSpanIndex * this.sliderTime;
+    let finalSpanEndTime = Math.max(this.time + this.duration / 2, (finalSpanStartTime + this.sliderTime) - legacyLastTickOffset);
+    let finalProgress = (finalSpanEndTime - finalSpanStartTime) / this.sliderTime;
+
+    if (this.spanCount % 2 == 0) finalProgress = 1 - finalProgress;
+
+    this.events.push({
+        type: "legacyLastTick", 
+        time: finalSpanEndTime,
+        pathProgress: finalProgress
+    });
+
+    this.events.push({
+        type: "tail", 
+        time: this.endTime,
+        pathProgress: this.spanCount % 2
+    });
+
+    this.nested = [];
+}
+JuiceStream.prototype = Object.create(Slider.prototype);
+JuiceStream.prototype.constructor = JuiceStream;
+JuiceStream.ID = 2;
+Catch.prototype.hitObjectTypes[JuiceStream.ID] = JuiceStream;
+JuiceStream.prototype.generateTicks = function(spanIndex, spanStartTime, spanDuration, reversed, length, tickDistance, minDistanceFromEnd) {
+    let ticks = [];
+    for (let d = tickDistance; d <= length; d += tickDistance) {
+        if (d >= length - minDistanceFromEnd)
+        break;
+
+        let pathProgress = d / length;
+        let timeProgress = reversed ? 1 - pathProgress : pathProgress;
+
+        ticks.push({type: "tick", time: spanStartTime + timeProgress * spanDuration, pathProgress});
+    }
+    return ticks;
+}
+
+JuiceStream.prototype.buildNested = function() {
+    this.nested = [];
+
+    let lastEvent = null;
+    for(let i = 0; i < this.events.length; i++) {
+        // generate tiny droplets since the last point
+        if (lastEvent != null)
+        {
+            let sinceLastTick = this.events[i].time - lastEvent.time;
+            if (sinceLastTick > 80)
+            {
+                let timeBetweenTiny = sinceLastTick;
+                while (timeBetweenTiny > 100) timeBetweenTiny /= 2;
+                for (let t = timeBetweenTiny; t < sinceLastTick; t += timeBetweenTiny) {
+                    let repeat = (t + lastEvent.time - this.time) * this.repeat / this.duration;
+                    repeat %= 2;
+                    if (repeat > 1) repeat = 2 - repeat;
+                    var point = this.curve.pointAt(repeat);
+                    this.nested.push(new PalpableCatchHitObject({
+                        type: "TinyDroplet",
+                        time: t + lastEvent.time,
+                        x: point.x,
+                        // x: this.curve.pointAt(lastEvent.pathProgress + (t / sinceLastTick) * (this.events[i].pathProgress - lastEvent.pathProgress)).x,
+                        color: this.color,
+                        radius: this.beatmap.tinyRadius,
+                    }, this.beatmap));
+                }
+            }
+        }
+
+        // this also includes LegacyLastTick and this is used for TinyDroplet generation above.
+        // this means that the final segment of TinyDroplets are increasingly mistimed where LegacyLastTickOffset is being applied.
+        lastEvent = this.events[i];
+
+        switch (this.events[i].type)
+        {
+            case "tick":
+                this.nested.push(new PalpableCatchHitObject({
+                    type: "Droplet",
+                    time: this.events[i].time,
+                    x: this.curve.pointAt(this.events[i].pathProgress).x,
+                    color: this.color,
+                    radius: this.beatmap.smallRadius,
+                }, this.beatmap));
+                break;
+
+            case "head":
+            case "tail":
+            case "repeat":
+                this.nested.push(new PalpableCatchHitObject({
+                    type: "Fruit",
+                    time: this.events[i].time,
+                    x: this.curve.pointAt(this.events[i].pathProgress).x,
+                    color: this.color,
+                    radius: this.beatmap.circleRadius,
+                }, this.beatmap));
+                break;
+        }
+    }
+
+    /* TODO BUG!!!
+     * 在预览 #4057684 时第一个滑条出现了
+     * PalpableCatchHitObject {beatmap: Catch, type: 'TinyDroplet', time: 464.57142857142895, …}
+     * PalpableCatchHitObject {beatmap: Catch, type: 'Droplet', time: 464.571428571429, …}
+     * 物件数量偏差导致后续随机数错误
+     * 暂时找不到原因，可能因为计算精度问题，临时手动将其剔除
+     */
+    let tmp_droplets = this.nested.filter((item) => item.type === "Droplet");
+    this.nested = this.nested.filter((item) => {
+        if (item.type != "TinyDroplet") return true;
+        for (let td = 0; td < tmp_droplets.length; td++) {
+            if (Math.abs(item.time - tmp_droplets[td].time) < 0.01) return false;
+        }
+        return true;
+    });
+
+    return this;
+}

nonebot_plugin_osubot/draw/osu_preview_templates/js/mania/hitnote.js

@@ -0,0 +1,21 @@
+function HitNote(data, beatmap)
+{
+    HitObject.call(this, data, beatmap);
+
+    this.column = Math.max(1, Math.min((this.position.x / this.beatmap.columnSize + 1) | 0, this.beatmap.keyCount)) - 1;
+}
+HitNote.prototype = Object.create(HitObject.prototype);
+HitNote.prototype.constructor = HitNote;
+HitNote.ID = 1;
+Mania.prototype.hitObjectTypes[HitNote.ID] = HitNote;
+HitNote.prototype.draw = function(scroll, ctx)
+{
+    ctx.beginPath();
+    ctx.rect(this.position.x, this.beatmap.calcY(this.position.y, scroll) - Mania.COLUMN_WIDTH / 3,
+        Mania.COLUMN_WIDTH, Mania.COLUMN_WIDTH / 3);
+    ctx.fillStyle = this.color;
+    ctx.fill();
+    ctx.strokeStyle = '#ccc';
+    ctx.lineWidth = 1;
+    ctx.stroke();
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/mania/holdnote.js

@@ -0,0 +1,37 @@
+function HoldNote(data, beatmap)
+{
+    HitNote.call(this, data, beatmap);
+
+    this.endTime = data[5].split(':')[0] | 0;
+}
+HoldNote.prototype = Object.create(HitNote.prototype);
+HoldNote.prototype.constructor = HoldNote;
+HoldNote.ID = 128;
+Mania.prototype.hitObjectTypes[HoldNote.ID] = HoldNote;
+HoldNote.WIDTH_SCALE = 0.8;
+HoldNote.OPACITY = 0.88;
+HoldNote.prototype.draw = function(scroll, ctx)
+{
+    var sy = this.beatmap.calcY(this.position.y, scroll) - Mania.COLUMN_WIDTH / 3,
+        ey = this.beatmap.calcY(this.endPosition.y, scroll) - Mania.COLUMN_WIDTH / 3;
+
+    var w = Mania.COLUMN_WIDTH * HoldNote.WIDTH_SCALE;
+    ctx.globalAlpha = HoldNote.OPACITY;
+    ctx.beginPath();
+    ctx.rect(this.position.x + (Mania.COLUMN_WIDTH - w) / 2, ey, w, sy - ey);
+    ctx.fillStyle = this.color;
+    ctx.fill();
+    ctx.globalAlpha = 1;
+
+    ctx.beginPath();
+    ctx.rect(this.position.x, sy, Mania.COLUMN_WIDTH, Mania.COLUMN_WIDTH / 3);
+    ctx.fill();
+    ctx.strokeStyle = '#ccc';
+    ctx.lineWidth = 1;
+    ctx.stroke();
+
+    ctx.beginPath();
+    ctx.rect(this.position.x, ey, Mania.COLUMN_WIDTH, Mania.COLUMN_WIDTH / 3);
+    ctx.fill();
+    ctx.stroke();
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/mania/mania.js

@@ -0,0 +1,164 @@
+function Mania(osu)
+{
+    Scroll.call(this, osu);
+
+
+    this.scrollSpeed = Mania.SCROLL_SPEED;
+    //this.columnStart = Mania.COLUMN_START;
+    this.columnStart = (Beatmap.WIDTH - Mania.COLUMN_WIDTH * this.keyCount) / 2
+
+    for (var i = 0; i < this.keyCount; i++)
+    {
+        this.Colors[i] = Mania.DEFAULT_COLORS[i & 1];
+    }
+    var p = this.keyCount / 2;
+    if (this.keyCount & 1)
+    {
+        this.Colors[p | 0] = Mania.DEFAULT_COLORS[2];
+    }
+    else
+    {
+        this.Colors = this.Colors.slice(0, p).concat(this.Colors.slice(p - 1));
+    }
+
+
+    for (var i = 0; i < this.HitObjects.length; i++)
+    {
+        var hitObject = this.HitObjects[i];
+        hitObject.color = this.Colors[hitObject.column];
+        hitObject.position.x = Mania.COLUMN_WIDTH * hitObject.column;
+        hitObject.position.y = this.scrollAt(hitObject.time);
+        hitObject.endPosition.y = this.scrollAt(hitObject.endTime);
+    }
+}
+Mania.prototype = Object.create(Scroll.prototype, {
+    keyCount: {
+        get: function()
+        {
+            return this.CircleSize;
+        }
+    },
+    columnSize: {
+        get: function()
+        {
+            return Beatmap.MAX_X / this.keyCount;
+        }
+    }
+});
+Mania.prototype.constructor = Mania;
+Mania.prototype.hitObjectTypes = {};
+Mania.ID = 3;
+Beatmap.modes[Mania.ID] = Mania;
+Mania.DEFAULT_COLORS = [
+    '#5bf',
+    '#ccc',
+    '#da2'
+];
+Mania.COLUMN_START = 130;
+Mania.HIT_POSITION = 400;
+Mania.COLUMN_WIDTH = 30;
+let savedSpeed = window.localStorage.getItem("SCROLL_SPEED");
+Mania.SCROLL_SPEED = (savedSpeed) ? parseInt(savedSpeed) : 20;
+Mania.prototype.calcY = function(y, scroll)
+{
+    return Mania.HIT_POSITION - (y - scroll) * this.scrollSpeed * 0.035;
+};
+Mania.prototype.update = function(ctx)
+{
+    ctx.translate(this.columnStart, 0);
+};
+Mania.prototype.draw = function(time, ctx)
+{
+    if (typeof this.tmp.first == 'undefined')
+    {
+        this.tmp.first = 0;
+        this.tmp.last = -1;
+        this.tmp.barLine = 0;
+    }
+
+    var scroll = this.scrollAt(time);
+    while (this.tmp.first < this.HitObjects.length &&
+        time > this.HitObjects[this.tmp.first].endTime)
+    {
+        this.tmp.first++;
+    }
+    while (this.tmp.last + 1 < this.HitObjects.length)
+    {
+        var hitObject = this.HitObjects[this.tmp.last + 1];
+        if (this.calcY(hitObject.position.y, scroll) < -Mania.COLUMN_WIDTH)
+        {
+            break;
+        }
+        this.tmp.last++;
+    }
+    while (this.tmp.barLine < this.barLines.length &&
+        this.calcY(this.barLines[this.tmp.barLine], scroll) > Beatmap.MAX_Y)
+    {
+        this.tmp.barLine++;
+    }
+    for (var i = this.tmp.barLine; i < this.barLines.length && this.calcY(this.barLines[i], scroll) > -Mania.COLUMN_WIDTH; i++)
+    {
+        var barLine = this.calcY(this.barLines[i], scroll);
+        ctx.beginPath();
+        ctx.moveTo(0, barLine);
+        ctx.lineTo(Mania.COLUMN_WIDTH * this.keyCount, barLine);
+        ctx.strokeStyle = '#fff';
+        ctx.lineWidth = 1;
+        ctx.stroke();
+    }
+    for (var i = this.tmp.first; i <= this.tmp.last; i++)
+    {
+        var hitObject = this.HitObjects[i];
+        if (time > hitObject.endTime)
+        {
+            continue;
+        }
+        hitObject.draw(scroll, ctx);
+    }
+    ctx.clearRect(0, Mania.HIT_POSITION, Beatmap.WIDTH, Beatmap.HEIGHT - Mania.HIT_POSITION);
+};
+Mania.prototype.processBG = function(ctx)
+{
+    ctx.beginPath();
+    ctx.rect(0, 0, Mania.COLUMN_WIDTH * this.keyCount, Beatmap.HEIGHT);
+    ctx.strokeStyle = '#ddd';
+    ctx.lineWidth = 8;
+    ctx.stroke();
+    ctx.fillStyle = '#000';
+    ctx.fill();
+
+    for (var i = 0; i < this.keyCount; i++)
+    {
+        var x = Mania.COLUMN_WIDTH * i;
+
+        ctx.beginPath();
+        ctx.moveTo(x, 0);
+        ctx.lineTo(x, Mania.HIT_POSITION);
+        ctx.strokeStyle = '#fff';
+        ctx.lineWidth = 1;
+        ctx.stroke();
+
+        ctx.beginPath();
+        ctx.rect(x, Mania.HIT_POSITION, Mania.COLUMN_WIDTH, Beatmap.HEIGHT - Mania.HIT_POSITION);
+        ctx.fillStyle = this.Colors[i];
+        ctx.fill();
+        ctx.strokeStyle = '#fff';
+        ctx.lineWidth = 3;
+        ctx.stroke();
+    }
+    var x = Mania.COLUMN_WIDTH * this.keyCount;
+    ctx.beginPath();
+    ctx.moveTo(x, 0);
+    ctx.lineTo(x, Mania.HIT_POSITION);
+    ctx.strokeStyle = '#fff';
+    ctx.lineWidth = 1;
+    ctx.stroke();
+    // HIT POSITION
+    ctx.beginPath();
+    ctx.rect(0, Mania.HIT_POSITION, Mania.COLUMN_WIDTH * this.keyCount, Mania.COLUMN_WIDTH / 3);
+    ctx.strokeStyle = '#fff';
+    ctx.lineWidth = 2;
+    ctx.stroke();
+    ctx.fillStyle = '#568';
+    ctx.fill();
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/preview.js

@@ -0,0 +1,61 @@
+var bgblob;
+function Preview(SCALE = 0.2) {
+    this.screen = document.createElement('canvas');
+    this.screen.width = Beatmap.WIDTH;
+    this.screen.height = Beatmap.HEIGHT;
+    this.ctx = this.screen.getContext('2d');
+    this.ctx.scale(SCALE, SCALE);
+    this.startTime = 0;
+    this.endTime = 0;
+    this.previewTime = -1;
+
+    var self = this;
+}
+Preview.prototype.load = function (osufile, success, fail) {
+    if (typeof this.xhr != 'undefined') {
+        this.xhr.abort();
+    }
+
+    var self = this;
+    try {
+        self.beatmap = Beatmap.parse(osufile);
+
+        self.ctx.restore();
+        self.ctx.save();
+        self.beatmap.update(self.ctx);
+        self.at(0);
+
+        self.previewTime = self.beatmap.PreviewTime > 0 ? self.beatmap.PreviewTime : -1;
+
+        self.startTime = self.beatmap.HitObjects.length > 0 ? self.beatmap.HitObjects[0].time - 1000 : 0;
+        if (self.startTime < 0) {
+            self.startTime = 0;
+        }
+        self.endTime = self.beatmap.HitObjects.length > 0 ? self.beatmap.HitObjects[self.beatmap.HitObjects.length - 1].endTime : 0;
+
+        if (typeof success == 'function') {
+            success.call(self);
+        }
+    }
+    catch (e) {
+        if (typeof fail == 'function') {
+            fail.call(self, e);
+        }
+    }
+};
+Preview.prototype.at = function (time) {
+    if (time > this.endTime) {
+        time = this.endTime;
+    }
+    if (time < this.startTime) {
+        time = this.startTime;
+    }
+    this.ctx.save();
+    this.ctx.setTransform(1, 0, 0, 1, 0, 0);
+    this.ctx.clearRect(0, 0, Beatmap.WIDTH, Beatmap.HEIGHT);
+    this.ctx.restore();
+    if (typeof this.beatmap.processBG != 'undefined') {
+        this.beatmap.processBG(this.ctx);
+    }
+    this.beatmap.draw(time, this.ctx);
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/standard/curve/bezier2.js

@@ -0,0 +1,33 @@
+function Bezier2(points)
+{
+    // https://github.com/itdelatrisu/opsu/blob/master/src/itdelatrisu/opsu/objects/curves/Bezier2.java
+    if (points.length < 2)
+    {
+        throw 'invalid data';
+    }
+
+    this.points = points;
+    var approxLength = 0;
+    for (var i = 1; i < this.points.length; i++)
+    {
+        approxLength += this.points[i].distanceTo(this.points[i - 1]);
+    }
+
+    CurveType.call(this, approxLength);
+}
+Bezier2.prototype = Object.create(CurveType.prototype);
+Bezier2.prototype.constructor = Bezier2;
+Bezier2.prototype.pointAt = function(t)
+{
+    var n = this.points.length - 1,
+        point = new Point(),
+        combination = 1;
+    for (var i = 0; i <= n; i++)
+    {
+        var bernstein = combination * Math.pow(t, i) * Math.pow(1 - t, n - i);
+        point.x += this.points[i].x * bernstein;
+        point.y += this.points[i].y * bernstein;
+        combination = combination * (n - i) / (i + 1);
+    }
+    return point;
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/standard/curve/catmullcurve.js

@@ -0,0 +1,34 @@
+function CatmullCurve(points, pixelLength)
+{
+    // https://github.com/itdelatrisu/opsu/blob/master/src/itdelatrisu/opsu/objects/curves/CatmullCurve.java
+    var catmulls = [],
+        controls = [];
+    if (!points[0].equalTo(points[1]))
+    {
+        controls.push(points[0]);
+    }
+    for (var i = 0; i < points.length; i++)
+    {
+        controls.push(points[i]);
+        try
+        {
+            catmulls.push(new CentripetalCatmullRom(controls));
+            controls.shift();
+        }
+        catch (e) {}
+    }
+    var point2 = points.slice(-2);
+    if (!point2[1].equalTo(point2[0]))
+    {
+        controls.push(point2[1]);
+    }
+    try
+    {
+        catmulls.push(new CentripetalCatmullRom(controls));
+    }
+    catch (e) {}
+
+    EqualDistanceMultiCurve.call(this, catmulls, pixelLength);
+};
+CatmullCurve.prototype = Object.create(EqualDistanceMultiCurve.prototype);
+CatmullCurve.prototype.constructor = CatmullCurve;

nonebot_plugin_osubot/draw/osu_preview_templates/js/standard/curve/centripetalcatmullrom.js

@@ -0,0 +1,30 @@
+function CentripetalCatmullRom(points)
+{
+    // https://github.com/itdelatrisu/opsu/blob/master/src/itdelatrisu/opsu/objects/curves/CentripetalCatmullRom.java
+    // needs 4 points
+    if (points.length != 4)
+    {
+        throw 'invalid data';
+    }
+
+    this.points = points;
+    var approxLength = 0;
+    for (var i = 1; i < 4; i++)
+    {
+        approxLength += this.points[i].distanceTo(this.points[i - 1]);
+    }
+
+    CurveType.call(this, approxLength / 2);
+}
+CentripetalCatmullRom.prototype = Object.create(CurveType.prototype);
+CentripetalCatmullRom.prototype.constructor = CentripetalCatmullRom;
+CentripetalCatmullRom.prototype.pointAt = function(t)
+{
+    t = Math.lerp(1, 2, t);
+    var A1 = this.points[0].clone().scale(1 - t).translate(this.points[1].clone().scale(t));
+    var A2 = this.points[1].clone().scale(2 - t).translate(this.points[2].clone().scale(t - 1));
+    var A3 = this.points[2].clone().scale(3 - t).translate(this.points[3].clone().scale(t - 2));
+    var B1 = A1.clone().scale(2 - t).translate(A2.clone().scale(t));
+    var B2 = A2.clone().scale(3 - t).translate(A3.clone().scale(t - 1));
+    return B1.clone().scale(2 - t).translate(B2.clone().scale(t - 1)).scale(0.5);
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/standard/curve/circumstancedcircle.js

@@ -0,0 +1,47 @@
+function CircumscribedCircle(points, pixelLength)
+{
+    var a = points[0].x - points[1].x, b = points[0].y - points[1].y,
+        c = points[1].x - points[2].x, d = points[1].y - points[2].y,
+        q = (a * d - b * c) * 2,
+        l0 = points[0].x * points[0].x + points[0].y * points[0].y,
+        l1 = points[1].x * points[1].x + points[1].y * points[1].y,
+        l2 = points[2].x * points[2].x + points[2].y * points[2].y,
+        x = ((l0 - l1) * d + (l1 - l2) * -b) / q,
+        y = ((l0 - l1) * -c + (l1 - l2) * a) / q,
+        dx = points[0].x - x,
+        dy = points[0].y - y,
+        r = Math.hypot(dx, dy),
+        base = Math.atan2(dy, dx),
+        t = pixelLength / r * Math.ccw(points[0], points[1], points[2]);
+    if (!t)
+    {
+        // when points[2] is missing or vectors are parallel
+        throw 'invalid data';
+    }
+    this.circle = {
+        x: x,
+        y: y,
+        radius: r
+    };
+    this.angle = {
+        base: base,
+        delta: t
+    };
+
+    var nCurve = pixelLength / Curve.PRECISION | 0;
+    this.path = [];
+    for (var i = 0; i <= nCurve; i++)
+    {
+        this.path[i] = this.pointAt(i / nCurve);
+    }
+
+    Curve.call(this);
+};
+CircumscribedCircle.prototype = Object.create(Curve.prototype);
+CircumscribedCircle.prototype.constructor = CircumscribedCircle;
+CircumscribedCircle.prototype.pointAt = function(t)
+{
+    var angle = this.angle.base + this.angle.delta * t;
+    return new Point(this.circle.x + Math.cos(angle) * this.circle.radius,
+        this.circle.y + Math.sin(angle) * this.circle.radius);
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/standard/curve/curve.js

@@ -0,0 +1,25 @@
+function Curve()
+{
+    this.startAngle = this.path[0].angleTo(this.path[1]);
+    var path2 = this.path.slice(-2);
+    this.endAngle = path2[1].angleTo(path2[0]);
+}
+Curve.prototype.path = undefined;
+Curve.prototype.pointAt = undefined;
+Curve.PRECISION = 5;
+Curve.parse = function(sliderType, points, pixelLength)
+{
+    try
+    {
+        if (sliderType == 'P')
+        {
+            return new CircumscribedCircle(points, pixelLength);
+        }
+        if (sliderType == 'C')
+        {
+            return new CatmullCurve(points, pixelLength);
+        }
+    }
+    catch(e) {}
+    return new LinearBezier(points, pixelLength, sliderType == 'L');
+}

nonebot_plugin_osubot/draw/osu_preview_templates/js/standard/curve/curvetype.js

@@ -0,0 +1,17 @@
+function CurveType(approxLength)
+{
+    // https://github.com/itdelatrisu/opsu/blob/master/src/itdelatrisu/opsu/objects/curves/CurveType.java
+    var points = (approxLength / 4 | 0) + 1;
+    this.path = [];
+    for (var i = 0; i <= points; i++)
+    {
+        this.path[i] = this.pointAt(i / points);
+    }
+
+    this.distance = [ 0 ];
+    for (var i = 1; i <= points; i++)
+    {
+        this.distance[i] = this.path[i].distanceTo(this.path[i - 1]);
+    }
+}
+CurveType.prototype.pointAt = undefined;