nonebot-plugin-osubot 6.22.1__py3-none-any.whl → 6.26.4__py3-none-any.whl

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

@@ -0,0 +1,170 @@
+function Standard(osu)
+{
+    Beatmap.call(this, osu);
+
+    let savedDefaultColor = window.localStorage.getItem("DefaultColor");
+    this.useDefaultColor = (savedDefaultColor) ? parseInt(savedDefaultColor) : 0;
+
+    let savedColorChange = window.localStorage.getItem("ColorChange");
+    this.colorChange = (savedColorChange) ? parseInt(savedColorChange) : 0;
+
+    if (this.Colors.length && !this.useDefaultColor) {
+        this.Colors.push(this.Colors.shift());
+    }
+    else
+    {
+        this.Colors = Standard.DEFAULT_COLORS;
+    }
+
+    var combo = 1,
+        comboIndex = -1,
+        setComboIndex = 1;
+    for (var i = 0; i < this.HitObjects.length; i++)
+    {
+        var hitObject = this.HitObjects[i];
+        if (hitObject instanceof Spinner)
+        {
+            setComboIndex = 1;
+        }
+        else if (hitObject.newCombo || setComboIndex)
+        {
+            combo = 1;
+            comboIndex = ((comboIndex + 1) + hitObject.comboSkip) % this.Colors.length;
+            setComboIndex = 0;
+        }
+        hitObject.combo = combo++;
+        hitObject.color = (this.colorChange) ? this.Colors[i % this.Colors.length] : this.Colors[comboIndex];
+    }
+
+
+    // calculate stacks
+    // https://gist.github.com/peppy/1167470
+    for (var i = this.HitObjects.length - 1; i > 0; i--)
+    {
+        var hitObject = this.HitObjects[i];
+        if (hitObject.stack != 0 || hitObject instanceof Spinner)
+        {
+            continue;
+        }
+
+        for (var n = i - 1; n >= 0; n--)
+        {
+            var hitObjectN = this.HitObjects[n];
+            if (hitObjectN instanceof Spinner)
+            {
+                continue;
+            }
+
+            if (hitObject.time - hitObjectN.endTime > this.approachTime * this.StackLeniency)
+            {
+                break;
+            }
+
+            if (hitObject.position.distanceTo(hitObjectN.endPosition) < Standard.STACK_LENIENCE)
+            {
+                if (hitObjectN instanceof Slider)
+                {
+                    var offset = hitObject.stack - hitObjectN.stack + 1;
+                    for (var j = n + 1; j <= i; j++)
+                    {
+                        var hitObjectJ = this.HitObjects[j];
+                        if (hitObjectJ.position.distanceTo(hitObjectN.endPosition) < Standard.STACK_LENIENCE)
+                        {
+                            hitObjectJ.stack -= offset;
+                        }
+                    }
+                    break;
+                }
+
+                hitObjectN.stack = hitObject.stack + 1;
+                hitObject = hitObjectN;
+            }
+        }
+    }
+
+    this.circleRadius = this.circleDiameter / 2;
+    this.circleBorder = this.circleRadius / 8;
+    this.shadowBlur = this.circleRadius / 15;
+}
+Standard.prototype = Object.create(Beatmap.prototype, {
+    approachTime: {
+        get: function()
+        {
+            return this.ApproachRate < 5
+                ? 1800 - this.ApproachRate * 120
+                : 1200 - (this.ApproachRate - 5) * 150;
+        }
+    },
+    // https://github.com/itdelatrisu/opsu/commit/8892973d98e04ebaa6656fe2a23749e61a122705
+    circleDiameter: {
+        get: function()
+        {
+            return 108.848 - this.CircleSize * 8.9646;
+        }
+    },
+    stackOffset: {
+        get: function()
+        {
+            return this.circleDiameter / 20;
+        }
+    }
+});
+Standard.prototype.constructor = Standard;
+Standard.prototype.hitObjectTypes = {};
+Standard.ID = 0;
+Beatmap.modes[Standard.ID] = Standard;
+Standard.DEFAULT_COLORS = [
+    'rgb(0,202,0)',
+    'rgb(18,124,255)',
+    'rgb(242,24,57)',
+    'rgb(255,255,0)'
+];
+Standard.STACK_LENIENCE = 3;
+Standard.prototype.update = function(ctx)
+{
+    ctx.shadowColor = '#666';
+    ctx.lineCap = 'round';
+    ctx.lineJoin = 'round';
+    try
+    {
+        // this code will fail in Firefox(<~ 44)
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=941146
+        ctx.font = this.circleRadius + 'px "Comic Sans MS", cursive, sans-serif';
+    }
+    catch (e) {}
+    ctx.textAlign = 'center';
+    ctx.textBaseline = 'middle';
+    ctx.translate((Beatmap.WIDTH - Beatmap.MAX_X) / 2, (Beatmap.HEIGHT - Beatmap.MAX_Y) / 2);
+};
+Standard.prototype.draw = function(time, ctx)
+{
+    if (typeof this.tmp.first == 'undefined')
+    {
+        this.tmp.first = 0;
+        this.tmp.last = -1;
+    }
+
+    while (this.tmp.first < this.HitObjects.length)
+    {
+        var hitObject = this.HitObjects[this.tmp.first];
+        if (time <= hitObject.endTime + hitObject.__proto__.constructor.FADE_OUT_TIME)
+        {
+            break;
+        }
+        this.tmp.first++;
+    }
+    while (this.tmp.last + 1 < this.HitObjects.length &&
+        time >= this.HitObjects[this.tmp.last + 1].time - this.approachTime)
+    {
+        this.tmp.last++;
+    }
+    for (var i = this.tmp.last; i >= this.tmp.first; i--)
+    {
+        var hitObject = this.HitObjects[i];
+        if (time > hitObject.endTime + hitObject.__proto__.constructor.FADE_OUT_TIME)
+        {
+            continue;
+        }
+        hitObject.draw(time, ctx);
+    }
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/taiko/donkat.js

@@ -0,0 +1,40 @@
+function DonKat(data, beatmap)
+{
+    HitCircle.call(this, data, beatmap);
+
+}
+DonKat.prototype = Object.create(HitCircle.prototype, {
+    don: {
+        get: function()
+        {
+            return !this.kai | 0;
+        }
+    },
+    kai: {
+        get: function()
+        {
+            return ((this.hitSound & 10) != 0) | 0;
+        }
+    },
+    dai: {
+        get: function()
+        {
+            return this.hitSound & 4;
+        }
+    }
+});
+DonKat.prototype.constructor = DonKat;
+DonKat.ID = 1;
+Taiko.prototype.hitObjectTypes[DonKat.ID] = DonKat;
+DonKat.prototype.draw = function(scroll, ctx)
+{
+    var diam = Taiko.DIAMETER * (this.dai ? 1.5 : 1);
+    var border = 3;
+    ctx.beginPath();
+    ctx.arc(this.beatmap.calcX(this.position.x, scroll), 0, diam / 2 - border / 2, -Math.PI, Math.PI);
+    ctx.fillStyle = Taiko.DEFAULT_COLORS[this.kai];
+    ctx.fill();
+    ctx.strokeStyle = '#fff';
+    ctx.lineWidth = border;
+    ctx.stroke();
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/taiko/drumroll.js

@@ -0,0 +1,34 @@
+function Drumroll(data, beatmap)
+{
+    Slider.call(this, data, beatmap);
+
+}
+Drumroll.prototype = Object.create(Slider.prototype, {});
+Drumroll.prototype.constructor = Drumroll;
+Drumroll.ID = 2;
+Taiko.prototype.hitObjectTypes[Drumroll.ID] = Drumroll;
+Drumroll.prototype.draw = function(scroll, ctx)
+{
+    var diam = Taiko.DIAMETER;
+    var border = 3;
+
+    ctx.beginPath();
+    ctx.moveTo(this.beatmap.calcX(this.position.x, scroll), 0);
+    ctx.lineTo(this.beatmap.calcX(this.endPosition.x, scroll), 0);
+
+    ctx.strokeStyle = '#333';
+    ctx.lineWidth = diam;
+    ctx.stroke();
+
+    ctx.strokeStyle = Taiko.DEFAULT_COLORS[2];
+    ctx.lineWidth = diam - border;
+    ctx.stroke();
+
+    ctx.beginPath();
+    ctx.arc(this.beatmap.calcX(this.position.x, scroll), 0, diam / 2 - border / 2, -Math.PI, Math.PI);
+    ctx.fillStyle = Taiko.DEFAULT_COLORS[2];
+    ctx.fill();
+    ctx.strokeStyle = '#fff';
+    ctx.lineWidth = border;
+    ctx.stroke();
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/taiko/shaker.js

@@ -0,0 +1,58 @@
+function Shaker(data, beatmap)
+{
+    Spinner.call(this, data, beatmap);
+
+}
+Shaker.prototype = Object.create(Spinner.prototype, {});
+Shaker.prototype.constructor = Shaker;
+Shaker.ID = 8;
+Taiko.prototype.hitObjectTypes[Shaker.ID] = Shaker;
+Shaker.prototype.draw = function(scroll, ctx)
+{
+    var ds = this.beatmap.calcX(this.position.x, scroll);
+    if (ds > 0)
+    {
+        var diam = Taiko.DIAMETER * 1.5;
+        var border = 3;
+        ctx.beginPath();
+        ctx.arc(this.beatmap.calcX(this.position.x, scroll), 0, diam / 2 - border / 2, -Math.PI, Math.PI);
+        ctx.fillStyle = Taiko.DEFAULT_COLORS[2];
+        ctx.fill();
+        ctx.strokeStyle = '#fff';
+        ctx.lineWidth = border;
+        ctx.stroke();
+    }
+    else
+    {
+        ctx.save();
+        ctx.setTransform(1, 0, 0, 1, 0, 0);
+        ctx.translate(Beatmap.WIDTH / 2, Beatmap.HEIGHT / 2);
+        // Spinner
+        ctx.beginPath();
+        ctx.arc(0, 0,
+            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();
+        // Approach
+        if (ds < 0 && scroll <= this.endPosition.x)
+        {
+            var scale = 1 + ds / this.beatmap.calcX(this.endPosition.x, this.position.x);
+            ctx.beginPath();
+            ctx.arc(0, 0,
+                (Spinner.RADIUS - Spinner.BORDER_WIDTH / 2) * scale, -Math.PI, Math.PI);
+            ctx.globalCompositeOperation = 'source-over';
+            ctx.shadowBlur = 3;
+            ctx.strokeStyle = '#fff';
+            ctx.lineWidth = (Spinner.BORDER_WIDTH / 2) * scale;
+            ctx.stroke();
+        }
+        ctx.restore();
+    }
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/taiko/taiko.js

@@ -0,0 +1,120 @@
+function Taiko(osu)
+{
+    Scroll.call(this, osu);
+
+    for (var i = 0; i < this.HitObjects.length; i++)
+    {
+        var hitObject = this.HitObjects[i];
+        hitObject.position.x = this.scrollAt(hitObject.time);
+        hitObject.endPosition.x = this.scrollAt(hitObject.endTime);
+    }
+}
+Taiko.prototype = Object.create(Scroll.prototype, {
+
+});
+Taiko.prototype.constructor = Taiko;
+Taiko.prototype.hitObjectTypes = {};
+Taiko.ID = 1;
+Beatmap.modes[Taiko.ID] = Taiko;
+Taiko.DEFAULT_COLORS = [
+    '#eb452c',
+    '#438eac',
+    '#fcb806'
+];
+Taiko.DIAMETER = 56;
+Taiko.prototype.calcX = function(x, scroll)
+{
+    return (x - scroll) * 20 * (260) / 1000 / (this.SliderMultiplier * 8);
+};
+Taiko.prototype.update = function(ctx)
+{
+    ctx.shadowColor = '#666';
+    ctx.lineCap = 'round';
+    ctx.lineJoin = 'round';
+    ctx.textAlign = 'center';
+    ctx.textBaseline = 'middle';
+    ctx.translate(160, 200);
+};
+Taiko.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.calcX(hitObject.position.x, scroll) > Beatmap.WIDTH)
+        {
+            break;
+        }
+        this.tmp.last++;
+    }
+    while (this.tmp.barLine < this.barLines.length &&
+        this.calcX(this.barLines[this.tmp.barLine], scroll) < -Taiko.DIAMETER)
+    {
+        this.tmp.barLine++;
+    }
+    for (var i = this.tmp.barLine; i < this.barLines.length && this.calcX(this.barLines[i], scroll) < Beatmap.WIDTH; i++)
+    {
+        var barLine = this.calcX(this.barLines[i], scroll);
+        ctx.beginPath();
+        ctx.moveTo(barLine, -Taiko.DIAMETER);
+        ctx.lineTo(barLine, Taiko.DIAMETER);
+        ctx.strokeStyle = '#fff';
+        ctx.lineWidth = 1;
+        ctx.stroke();
+    }
+    for (var i = this.tmp.last; i >= this.tmp.first; i--)
+    {
+        var hitObject = this.HitObjects[i];
+        if (time > hitObject.endTime)
+        {
+            continue;
+        }
+        hitObject.draw(scroll, ctx);
+    }
+    ctx.clearRect(-160, -200, Taiko.DIAMETER * 2, 400);
+};
+Taiko.prototype.processBG = function(ctx)
+{
+    var offset = - Taiko.DIAMETER;
+    //ctx.drawImage(ctx.canvas, -160, offset, ctx.canvas.width, ctx.canvas.height);
+    //ctx.beginPath();
+    //ctx.rect(0, 0, Beatmap.WIDTH, offset);
+    //ctx.fillStyle = '#000';
+    //ctx.fill();
+
+    // rail
+    ctx.beginPath();
+    ctx.rect(-160, offset, Beatmap.WIDTH, Taiko.DIAMETER * 2);
+    ctx.strokeStyle = '#ddd';
+    ctx.lineWidth = 8;
+    ctx.stroke();
+    ctx.fillStyle = '#000';
+    ctx.fill();
+
+    // drum
+    ctx.beginPath();
+    ctx.rect(-160, offset, Taiko.DIAMETER * 2, Taiko.DIAMETER * 2);
+    ctx.fillStyle = '#ff0080';
+    ctx.fill();
+
+    var border = 6;
+    ctx.beginPath();
+    ctx.arc(0, 0, Taiko.DIAMETER / 2, -Math.PI, Math.PI);
+    ctx.fillStyle = 'rgba(255,255,255,.2)';
+    ctx.fill();
+    ctx.strokeStyle = 'rgba(255,255,255,.2)';
+    ctx.lineWidth = border;
+    ctx.stroke();
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/util.js

@@ -0,0 +1,61 @@
+Math.hypot = Math.hypot || function()
+{
+    var power = 0;
+    for (var i = 0; i < arguments.length; i++)
+    {
+        power += arguments[i] * arguments[i];
+    }
+    return Math.sqrt(power);
+};
+Math.lerp = Math.lerp || function(a, b, t)
+{
+    if (a instanceof Point)
+    {
+        return new Point(Math.lerp(a.x, b.x, t), Math.lerp(a.y, b.y, t));
+    }
+    return a + (b - a) * t;
+};
+/** Calculate point C's direction by line AB
+ * @return {Number}
+ * 1    C is counter-clockwise to AB
+ * 0    C is parallel to AB
+ * -1   C is clockwise to AB
+ */
+Math.ccw = function(a, b, c)
+{
+    var ret = (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);
+    if (ret > 0)
+    {
+        return 1;
+    }
+    if (ret < 0)
+    {
+        return -1;
+    }
+    return 0;
+};
+Math.clamp = function(num, min, max) {
+    if (num < min) return min;
+    if (num > max) return max;
+    return num;
+}
+// https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob#Polyfill
+if (!HTMLCanvasElement.prototype.toBlob)
+{
+    Object.defineProperty(HTMLCanvasElement.prototype, 'toBlob', {
+        value: function (callback, type, quality)
+        {
+
+            var binStr = atob(this.toDataURL(type, quality).split(',')[1]),
+                len = binStr.length,
+                arr = new Uint8Array(len);
+
+            for (var i = 0; i < len; i++)
+            {
+                arr[i] = binStr.charCodeAt(i);
+            }
+
+            callback(new Blob([ arr ], { type: type || 'image/png' }));
+        }
+    });
+}

nonebot_plugin_osubot/draw/osu_preview_templates/pic.html

@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+    <base href="{{ base_url }}">
+    <meta name="robots" content="nofollow, noindex, noarchive">
+    <title>gif生成测试 网址后加#bid</title>
+</head>
+
+
+<body class="h">
+    <img id="img"></img>
+
+    <script src="js/util.js"></script>
+
+    <script src="js/beatmap/beatmap.js"></script>
+    <script src="js/beatmap/timingpoint.js"></script>
+    <script src="js/beatmap/hitobject.js"></script>
+    <script src="js/beatmap/point.js"></script>
+    <script src="js/beatmap/scroll.js"></script>
+
+    <script src="js/standard/standard.js"></script>
+    <script src="js/standard/hitcircle.js"></script>
+    <script src="js/standard/slider.js"></script>
+    <script src="js/standard/curve/curve.js"></script>
+    <script src="js/standard/curve/equaldistancemulticurve.js"></script>
+    <script src="js/standard/curve/linearbezier.js"></script>
+    <script src="js/standard/curve/catmullcurve.js"></script>
+    <script src="js/standard/curve/curvetype.js"></script>
+    <script src="js/standard/curve/bezier2.js"></script>
+    <script src="js/standard/curve/centripetalcatmullrom.js"></script>
+    <script src="js/standard/curve/circumstancedcircle.js"></script>
+    <script src="js/standard/spinner.js"></script>
+
+    <script src="js/taiko/taiko.js"></script>
+    <script src="js/taiko/donkat.js"></script>
+    <script src="js/taiko/drumroll.js"></script>
+    <script src="js/taiko/shaker.js"></script>
+
+    <script src="js/catch/LegacyRandom.js"></script>
+    <script src="js/catch/catch.js"></script>
+    <script src="js/catch/fruit.js"></script>
+    <script src="js/catch/bananashower.js"></script>
+    <script src="js/catch/juicestream.js"></script>
+    <script src="js/catch/PalpableCatchHitObject.js"></script>
+
+    <script src="js/mania/mania.js"></script>
+    <script src="js/mania/hitnote.js"></script>
+    <script src="js/mania/holdnote.js"></script>
+
+    <script src="js/preview.js"></script>
+    <script src="gif.js/gif.js"></script>
+
+    <script>
+        const scaleValue = 0.5;
+        const durationValue = 10000;
+        const qualityValue = 10;
+        const timeSpanValue = 50;
+
+        const createImg = function () {
+            let preview = new Preview(scaleValue);
+            const osufile = `{{ osu_file }}`;
+            preview.load(osufile, function () {
+                let actualStartTime;
+                const previewEndTime = preview.previewTime + durationValue;
+                if (previewEndTime <= preview.endTime) {
+                    // 使用谱面预览时间
+                    actualStartTime = preview.previewTime;
+                } else {
+                    // 预览时间加上持续时间超过谱面结束时间，使用用户指定的开始时间
+                    actualStartTime = preview.startTime;
+                }
+                const actualEndTime = durationValue === -1 ? preview.endTime : Math.min(actualStartTime + durationValue, preview.endTime);
+                let gif = new GIF({
+                    workers: 4,
+                    workerScript: "{{ worker_data_uri }}",
+                    quality: qualityValue,
+                    width: preview.screen.width * scaleValue,
+                    height: preview.screen.height * scaleValue,
+                    //transparent: "0x000000",
+                });
+
+                const totalFrames = Math.ceil((actualEndTime - actualStartTime) / timeSpanValue);
+                let currentFrame = 0;
+
+                // 添加帧
+                while (currentFrame <= totalFrames) {
+                    const t = actualStartTime + currentFrame * timeSpanValue;
+                    preview.at(t);
+
+                    gif.addFrame(preview.ctx, {
+                        copy: true,
+                        delay: timeSpanValue
+                    });
+                    currentFrame++;
+                }
+                gif.on('finished', function (blob) {
+                    document.getElementById("img").src = URL.createObjectURL(blob);
+                });
+                gif.render();
+            });
+        }
+        window.addEventListener('hashchange', createImg);
+        createImg();
+    </script>
+</body>
+
+</html>

nonebot_plugin_osubot/draw/rating.py

@@ -348,7 +348,8 @@ class PlayerRatingCalculation:
                 if user_info is None:
                     continue
                 if entry.user_id == user_id:
-                    average_scores.append(sum([entry.score for entry in game.scores]) / len(game.scores))
+                    # Optimize: calculate sum directly instead of creating list
+                    average_scores.append(sum(entry.score for entry in game.scores) / len(game.scores))
                     user_scores.append(entry.score)
                     number_of_games_by_user += 1
 
@@ -397,7 +398,8 @@ class PlayerRatingCalculation:
                 if entry.user_id == user_id:
                     for mod in entry.mods:
                         all_played_mods.add(mod)
-                    average_scores.append(sum([entry.score for entry in game.scores]) / len(game.scores))
+                    # Optimize: calculate sum directly instead of creating list
+                    average_scores.append(sum(entry.score for entry in game.scores) / len(game.scores))
                     user_scores.append(entry.score)
                     number_of_games_by_user += 1
             # 获取加时赛数据
@@ -454,7 +456,8 @@ class PlayerRatingCalculation:
                 if user_info is None:
                     continue
                 if entry.user_id == user_id:
-                    median_scores.append(median([entry.score for entry in game.scores]))
+                    # Optimize: calculate median directly instead of creating list
+                    median_scores.append(median(entry.score for entry in game.scores))
                     user_scores.append(entry.score)
                     number_of_games_by_user += 1