nonebot-plugin-osubot 6.24.0__py3-none-any.whl → 6.24.2__py3-none-any.whl

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;

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

@@ -0,0 +1,70 @@
+function EqualDistanceMultiCurve(curves, pixelLength)
+{
+    // https://github.com/itdelatrisu/opsu/blob/master/src/itdelatrisu/opsu/objects/curves/EqualDistanceMultiCurve.java
+    var nCurve = pixelLength / Curve.PRECISION | 0;
+    this.path = [];
+
+    var distanceAt = 0,
+        curveIndex = 0,
+        curve = curves[curveIndex],
+        pointIndex = 0,
+        startPoint = curve.path[0],
+        lastDistanceAt = 0;
+    // for each distance, try to get in between the two points that are between it
+    for (var i = 0; i <= nCurve; i++)
+    {
+        var prefDistance = i * pixelLength / nCurve | 0;
+        while (distanceAt < prefDistance)
+        {
+            lastDistanceAt = distanceAt;
+            startPoint = curve.path[pointIndex];
+
+            if (++pointIndex >= curve.path.length)
+            {
+                if (curveIndex + 1 < curves.length)
+                {
+                    curve = curves[++curveIndex];
+                    pointIndex = 0;
+                }
+                else
+                {
+                    pointIndex = curve.path.length - 1;
+                    if (lastDistanceAt == distanceAt)
+                    {
+                        // out of points even though the preferred distance hasn't been reached
+                        break;
+                    }
+                }
+            }
+            distanceAt += curve.distance[pointIndex];
+        }
+        var endPoint = curve.path[pointIndex];
+
+        // interpolate the point between the two closest distances
+        if (distanceAt - lastDistanceAt > 1)
+        {
+            this.path[i] = Math.lerp(startPoint, endPoint, (prefDistance - lastDistanceAt) / (distanceAt - lastDistanceAt));
+        }
+        else
+        {
+            this.path[i] = endPoint;
+        }
+    }
+
+    Curve.call(this);
+};
+EqualDistanceMultiCurve.prototype = Object.create(Curve.prototype);
+EqualDistanceMultiCurve.prototype.constructor = EqualDistanceMultiCurve;
+EqualDistanceMultiCurve.prototype.pointAt = function(t)
+{
+    var indexF = this.path.length * t,
+        index = indexF | 0;
+    if (index + 1 < this.path.length)
+    {
+        return Math.lerp(this.path[index], this.path[index + 1], indexF - index);
+    }
+    else
+    {
+        return this.path[this.path.length - 1];
+    }
+};

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

@@ -0,0 +1,40 @@
+function LinearBezier(points, pixelLength, linear)
+{
+    // https://github.com/itdelatrisu/opsu/blob/master/src/itdelatrisu/opsu/objects/curves/LinearBezier.java
+    var beziers = [],
+        controls = [],
+        last;
+    for (var i = 0; i < points.length; i++)
+    {
+        var point = points[i];
+        if (linear)
+        {
+            if (typeof last != 'undefined')
+            {
+                controls.push(point);
+                beziers.push(new Bezier2(controls));
+                controls = [];
+            }
+        }
+        else if (point.equalTo(last))
+        {
+            try
+            {
+                beziers.push(new Bezier2(controls));
+            }
+            catch (e) {}
+            controls = [];
+        }
+        controls.push(point);
+        last = point;
+    }
+    try
+    {
+        beziers.push(new Bezier2(controls));
+    }
+    catch (e) {}
+
+    EqualDistanceMultiCurve.call(this, beziers, pixelLength);
+};
+LinearBezier.prototype = Object.create(EqualDistanceMultiCurve.prototype);
+LinearBezier.prototype.constructor = LinearBezier;

nonebot_plugin_osubot/draw/osu_preview_templates/js/standard/hitcircle.js

@@ -0,0 +1,85 @@
+function HitCircle(data, beatmap)
+{
+    HitObject.call(this, data, beatmap);
+
+    this.stack = 0;
+}
+HitCircle.prototype = Object.create(HitObject.prototype, {
+    newCombo: {
+        get: function()
+        {
+            return this.flag & 4;
+        }
+    },
+    comboSkip: {
+        get: function()
+        {
+            return this.flag >> 4;
+        }
+    }
+});
+HitCircle.prototype.constructor = HitCircle;
+HitCircle.ID = 1;
+Standard.prototype.hitObjectTypes[HitCircle.ID] = HitCircle;
+HitCircle.FADE_IN_TIME = 375;
+HitCircle.FADE_OUT_TIME = 200;
+HitCircle.prototype.draw = function(time, ctx)
+{
+    var dt = this.time - time,
+        opacity = 1;
+    if (dt >= 0)
+    {
+        opacity = (this.beatmap.approachTime - dt) / HitCircle.FADE_IN_TIME;
+    }
+    else
+    {
+        opacity = 1 + dt / HitCircle.FADE_OUT_TIME;
+    }
+    ctx.globalAlpha = Math.max(0, Math.min(opacity, 1));
+
+    this.drawCircle(this.position, ctx);
+    this.drawText(this.position, this.combo, 0, ctx);
+    if (dt >= 0)
+    {
+        this.drawApproach(dt, ctx);
+    }
+};
+HitCircle.prototype.drawCircle = function(position, ctx)
+{
+    // HitCircle
+    ctx.beginPath();
+    ctx.arc(position.x - this.stack * this.beatmap.stackOffset,
+        position.y - this.stack * this.beatmap.stackOffset,
+        this.beatmap.circleRadius - this.beatmap.circleBorder / 2, -Math.PI, Math.PI);
+    ctx.shadowBlur = 0;
+    ctx.fillStyle = this.color;
+    ctx.fill();
+    // Overlay
+    ctx.shadowBlur = this.beatmap.shadowBlur;
+    ctx.strokeStyle = '#fff';
+    ctx.lineWidth = this.beatmap.circleBorder;
+    ctx.stroke();
+};
+HitCircle.prototype.drawText = function(position, text, deg, ctx)
+{
+    ctx.shadowBlur = this.beatmap.shadowBlur;
+    ctx.fillStyle = '#fff';
+    ctx.save();
+    ctx.translate(position.x - this.stack * this.beatmap.stackOffset,
+        position.y - this.stack * this.beatmap.stackOffset);
+    ctx.rotate(deg);
+    ctx.fillText(text, 0, 0);
+    ctx.restore();
+};
+HitCircle.prototype.drawApproach = function(dt, ctx)
+{
+    var scale = 1 + dt / this.beatmap.approachTime * 3;
+    ctx.beginPath();
+    ctx.arc(this.position.x - this.stack * this.beatmap.stackOffset,
+        this.position.y - this.stack * this.beatmap.stackOffset,
+        this.beatmap.circleRadius * scale - this.beatmap.circleBorder / 2, -Math.PI, Math.PI);
+    ctx.shadowBlur = 0;
+    ctx.strokeStyle = this.color;
+    ctx.lineWidth = this.beatmap.circleBorder / 2 * scale;
+    ctx.stroke();
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/standard/slider.js

@@ -0,0 +1,120 @@
+function Slider(data, beatmap)
+{
+    HitCircle.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];
+
+    var sliderTime = this.beatmap.timingPointAt(this.time).beatLength * (
+            this.pixelLength / this.beatmap.SliderMultiplier
+        ) / 100;
+    this.endTime += sliderTime * this.repeat;
+    this.duration = this.endTime - this.time;
+
+    this.curve = Curve.parse(sliderType, points, this.pixelLength);
+
+    this.endPosition = this.curve.pointAt(1);
+}
+Slider.prototype = Object.create(HitCircle.prototype);
+Slider.prototype.constructor = Slider;
+Slider.ID = 2;
+Standard.prototype.hitObjectTypes[Slider.ID] = Slider;
+Slider.FADE_IN_TIME = 375;
+Slider.FADE_OUT_TIME = 200;
+Slider.REVERSE_ARROW = String.fromCharCode(10132);
+Slider.OPACITY = 0.66;
+Slider.prototype.draw = function(time, ctx)
+{
+    var dt = this.time - time,
+        opacity = 1;
+    if (dt >= 0)
+    {
+        opacity = (this.beatmap.approachTime - dt) / Slider.FADE_IN_TIME;
+    }
+    else if (time > this.endTime)
+    {
+        opacity = 1 - (time - this.endTime) / Slider.FADE_OUT_TIME;
+    }
+    ctx.globalAlpha = Math.max(0, Math.min(opacity, 1));
+
+    this.drawPath(ctx);
+    // this.drawCircle(this.endPosition, ctx);
+    // this.drawCircle(this.position, ctx);
+
+    var repeat = -dt * this.repeat / this.duration;
+    //                                   this.repeat - this.repeat % 2: 홀수면 짝수로 내리기
+    if (this.repeat > 1 && repeat + 1 <= (this.repeat & ~1))
+    {
+        this.drawCircle(this.endPosition, ctx);
+        this.drawText(this.endPosition, Slider.REVERSE_ARROW, this.curve.endAngle, ctx);
+    }
+    //                              this.repeat - (this.repeat + 1) % 2: 짝수면 홀수로 내리기
+    if (repeat > 0 && repeat + 1 <= this.repeat - !(this.repeat & 1))
+    {
+        this.drawCircle(this.position, ctx);
+        this.drawText(this.position, Slider.REVERSE_ARROW, this.curve.startAngle, ctx);
+    }
+    else if (dt >= 0)
+    {
+        this.drawCircle(this.position, ctx);
+        this.drawText(this.position, this.combo, 0, ctx);
+    }
+
+    if (dt >= 0)
+    {
+        this.drawApproach(dt, ctx);
+    }
+    else if (time < this.endTime)
+    {
+        this.drawFollowCircle(repeat, ctx);
+    }
+};
+Slider.prototype.drawPath = function(ctx)
+{
+    ctx.save();
+    // Slider
+    ctx.globalAlpha *= Slider.OPACITY;
+    ctx.beginPath();
+    ctx.moveTo(this.position.x - this.stack * this.beatmap.stackOffset,
+        this.position.y - this.stack * this.beatmap.stackOffset);
+    for (var i = 1; i < this.curve.path.length; i++)
+    {
+        ctx.lineTo(this.curve.path[i].x - this.stack * this.beatmap.stackOffset,
+            this.curve.path[i].y - this.stack * this.beatmap.stackOffset);
+    }
+    ctx.shadowBlur = 0;
+    ctx.strokeStyle = this.color;
+    ctx.lineWidth = (this.beatmap.circleRadius - this.beatmap.circleBorder) * 2;
+    ctx.stroke();
+    // Border
+    ctx.globalCompositeOperation = 'destination-over';
+    ctx.shadowBlur = 0;
+    ctx.strokeStyle = '#fff';
+    ctx.lineWidth = this.beatmap.circleRadius * 2;
+    ctx.stroke();
+    ctx.restore();
+};
+Slider.prototype.drawFollowCircle = function(repeat, ctx)
+{
+    repeat %= 2;
+    if (repeat > 1)
+    {
+        repeat = 2 - repeat;
+    }
+    var point = this.curve.pointAt(repeat);
+    ctx.beginPath();
+    ctx.arc(point.x - this.stack * this.beatmap.stackOffset,
+        point.y - this.stack * this.beatmap.stackOffset,
+        this.beatmap.circleRadius - this.beatmap.circleBorder / 2, -Math.PI, Math.PI);
+    ctx.shadowBlur = this.beatmap.shadowBlur;
+    ctx.strokeStyle = '#fff';
+    ctx.lineWidth = this.beatmap.circleBorder;
+    ctx.stroke();
+}

nonebot_plugin_osubot/draw/osu_preview_templates/js/standard/spinner.js

@@ -0,0 +1,56 @@
+function Spinner(data, beatmap)
+{
+    HitCircle.call(this, data, beatmap);
+
+    this.endTime = data[5] | 0;
+    this.duration = this.endTime - this.time;
+}
+Spinner.prototype = Object.create(HitCircle.prototype);
+Spinner.prototype.constructor = Spinner;
+Spinner.ID = 8;
+Standard.prototype.hitObjectTypes[Spinner.ID] = Spinner;
+Spinner.FADE_IN_TIME = 500;
+Spinner.FADE_OUT_TIME = 200;
+Spinner.RADIUS = Beatmap.MAX_Y / 2;
+Spinner.BORDER_WIDTH = Spinner.RADIUS / 20;
+Spinner.prototype.draw = function(time, ctx)
+{
+    var dt = this.time - time,
+        opacity = 1;
+    if (dt >= 0)
+    {
+        opacity = (this.beatmap.approachTime - dt) / Spinner.FADE_IN_TIME;
+    }
+    else if (time > this.endTime)
+    {
+        opacity = 1 - (time - this.endTime) / Spinner.FADE_OUT_TIME;
+    }
+    ctx.globalAlpha = Math.max(0, Math.min(opacity, 1));
+    ctx.save();
+    // Spinner
+    ctx.beginPath();
+    ctx.arc(this.position.x, this.position.y,
+        Spinner.RADIUS - Spinner.BORDER_WIDTH / 2, -Math.PI, Math.PI);
+    ctx.globalCompositeOperation = 'destination-over';
+    ctx.shadowBlur = 0;
+    ctx.fillStyle = 'rgba(0,0,0,.4)';
+    ctx.fill();
+    // Border
+    ctx.shadowBlur = Spinner.BORDER_WIDTH;
+    ctx.strokeStyle = '#fff';
+    ctx.lineWidth = Spinner.BORDER_WIDTH;
+    ctx.stroke();
+    ctx.restore();
+    // Approach
+    if (dt < 0 && time <= this.endTime)
+    {
+        var scale = 1 + dt / this.duration;
+        ctx.beginPath();
+        ctx.arc(this.position.x, this.position.y,
+            (Spinner.RADIUS - Spinner.BORDER_WIDTH / 2) * scale, -Math.PI, Math.PI);
+        ctx.shadowBlur = 3;
+        ctx.strokeStyle = '#fff';
+        ctx.lineWidth = (Spinner.BORDER_WIDTH / 2) * scale;
+        ctx.stroke();
+    }
+};