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/beatmap/point.js

@@ -0,0 +1,55 @@
+function Point()
+{
+    if (arguments.length >= 2)
+    {
+        this.x = +arguments[0];
+        this.y = +arguments[1];
+    }
+    else if (arguments.length == 1)
+    {
+        this.x = +arguments[0][0];
+        this.y = +arguments[0][1];
+    }
+    else
+    {
+        this.x = 0;
+        this.y = 0;
+    }
+}
+Point.prototype.distanceTo = function(point)
+{
+    return Math.hypot(point.x - this.x, point.y - this.y);
+};
+Point.prototype.equalTo = function(point)
+{
+    return point instanceof Point &&
+        this.x == point.x && this.y == point.y;
+};
+Point.prototype.angleTo = function(point)
+{
+    return Math.atan2(point.y - this.y, point.x - this.x);
+};
+Point.prototype.clone = function()
+{
+    return new Point(this.x, this.y);
+};
+Point.prototype.translate = function(n)
+{
+    if (n instanceof Point)
+    {
+        this.x += n.x;
+        this.y += n.y;
+    }
+    else
+    {
+        this.x += n;
+        this.y += n;
+    }
+    return this;
+};
+Point.prototype.scale = function(n)
+{
+    this.x *= n;
+    this.y *= n;
+    return this;
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/beatmap/scroll.js

@@ -0,0 +1,45 @@
+function Scroll(osu)
+{
+    Beatmap.call(this, osu);
+
+    // dp for numerous call to this.scrollAt
+    this.scrollAtTimingPointIndex = [ 0 ];
+    var currentIdx = this.timingPointIndexAt(0),
+        current = this.TimingPoints[currentIdx],
+        base = this.TimingPoints[0],
+        scrollVelocity = base.beatLength / current.beatLength;
+    this.scrollAtTimingPointIndex[currentIdx] = current.time * scrollVelocity;
+    while (++currentIdx < this.TimingPoints.length)
+    {
+        var next = this.TimingPoints[currentIdx];
+        this.scrollAtTimingPointIndex[currentIdx] = (next.time - current.time) * scrollVelocity +
+            this.scrollAtTimingPointIndex[currentIdx - 1];
+        current = next;
+        scrollVelocity = base.beatLength / current.beatLength;
+    }
+
+    this.barLines = [];
+    var endTime = (this.HitObjects.length ? this.HitObjects[this.HitObjects.length - 1].endTime : 0) + 1;
+    for (var i = 0; i < this.TimingPoints.length; i++)
+    {
+        var current = this.TimingPoints[i],
+            base = current.parent || current,
+            barLength = base.beatLength * base.meter,
+            next = this.TimingPoints[i + 1],
+            barLineLimit = next ? (next.parent || next).time : endTime;
+        for (var barTime = base.time; barTime < barLineLimit; barTime += barLength)
+        {
+            this.barLines.push(this.scrollAt(barTime));
+        }
+    }
+}
+Scroll.prototype = Object.create(Beatmap.prototype);
+Scroll.prototype.constructor = Scroll;
+Scroll.prototype.scrollAt = function(time)
+{
+    var currentIdx = this.timingPointIndexAt(time),
+        current = this.TimingPoints[currentIdx],
+        base = this.TimingPoints[0],
+        scrollVelocity = base.beatLength / current.beatLength;
+    return (time - current.time) * scrollVelocity + this.scrollAtTimingPointIndex[currentIdx];
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/beatmap/timingpoint.js

@@ -0,0 +1,35 @@
+function TimingPoint(line)
+{
+    var data = line.split(',');
+    if (data.length < 2)
+    {
+        throw 'invalid data';
+    }
+
+    this.time = data[0] | 0;
+    this.beatLength = +data[1];
+    this.meter = (data[2] | 0) || 4;
+    this.kiai = (data[7] | 0) % 2;
+
+    // this is non-inherited timingPoint
+    if (this.beatLength >= 0)
+    {
+        TimingPoint.parent = this;
+        this.sliderVelocity = 1;
+    }
+    else
+    {
+        this.parent = TimingPoint.parent;
+        this.sliderVelocity = -100 / this.beatLength;
+        this.beatLength = this.parent.beatLength / this.sliderVelocity;
+        this.meter = this.parent.meter;
+    }
+}
+Object.defineProperties(TimingPoint.prototype, {
+    bpm: {
+        get: function()
+        {
+            return 60000 / this.beatLength;
+        }
+    }
+});

nonebot_plugin_osubot/draw/osu_preview_templates/js/catch/LegacyRandom.js

@@ -0,0 +1,81 @@
+class LegacyRandom{
+    constructor(x) {
+        this.int_to_real = 1 / 2147483648;
+        this.int_mask = 0x7FFFFFFF;
+        this.x = x || Date.now();
+        this.x = this.ToUInt(this.x);
+        this._X = this.x;
+        this.y = 842502087;
+        this._Y = this.y;
+        this.z = 3579807591;
+        this._Z = this.z;
+        this.w = 273326509;
+        this._W = this.w;
+
+        this.bitBuffer;
+        this.bitIndex = 32;
+    }
+
+    ToInt(num) {
+        if (num > 2147483647) return this.ToInt(num - 4294967296);
+        else if (num < -2147483648) return this.ToInt(4294967296 + num);
+        else return parseInt(num);
+    }
+
+    ToUInt(num) {
+        if (num > 4294967296) return this.ToUInt(num - 4294967296);
+        if (num < 0) return this.ToUInt(4294967296 + num);
+        else return num;
+    }
+
+    NextUInt() {
+        let t = this.ToUInt(this._X ^ this.ToUInt(this._X << 11));
+        this._X = this._Y;
+        this._Y = this._Z;
+        this._Z = this._W;
+        let tmp = this.ToUInt(this._W >>> 19);
+        tmp = this.ToUInt(this._W ^ tmp);
+        tmp = this.ToUInt(tmp ^ t);
+        let tmp2 = this.ToUInt(t >>> 8);
+        this._W = this.ToUInt(tmp ^ tmp2);
+        return this._W;
+    }
+
+    Next() {
+        if (arguments.length <= 0) {
+            return this.ToInt(this.int_mask & this.NextUInt());
+        }
+        else if (arguments.length === 1) { // upperBound
+            return this.ToInt(this.NextDouble() * arguments[0]);
+        }
+        else { // lowerBound, upperBound
+            return this.ToInt(arguments[0] + this.NextDouble() * (arguments[1] - arguments[0]));
+        }
+    }
+
+    NextDouble() {
+        return this.int_to_real * this.Next();
+    }
+
+    NextBool() {
+        if (this.bitIndex == 32)
+        {
+            this.bitBuffer = this.NextUInt();
+            this.bitIndex = 1;
+
+            return ((this.bitBuffer & 1) == 1);
+        }
+
+        this.bitIndex++;
+        this.bitBuffer = this.bitBuffer >>> 1;
+        return ((this.bitBuffer & 1) == 1);
+    }
+}
+/*
+let rng = new LegacyRandom(1337);
+for(let i = 0; i < 1000;  i++)
+{
+    rng.NextDouble();
+}
+console.log(rng.NextDouble());
+*/

nonebot_plugin_osubot/draw/osu_preview_templates/js/catch/PalpableCatchHitObject.js

@@ -0,0 +1,53 @@
+function PalpableCatchHitObject(data, beatmap)
+{
+    this.beatmap = beatmap;
+    this.type = data.type;
+    this.time = data.time;
+    this.x = data.x;
+    this.color = data.color;
+    this.radius = data.radius;
+    this.hyperDash = false;
+}
+PalpableCatchHitObject.prototype.draw = function(time, ctx)
+{
+    var dt = this.time - time;
+    if (dt >= -this.beatmap.FALLOUT_TIME) {
+        if (this.type === "Banana") this.drawBanana({x: this.x, y: (1 - dt / this.beatmap.approachTime) * Beatmap.HEIGHT - this.beatmap.CATCHER_HEIGHT}, ctx);
+        else {
+            if (this.hyperDash) this.drawDashCircle({x: this.x, y: (1 - dt / this.beatmap.approachTime) * Beatmap.HEIGHT - this.beatmap.CATCHER_HEIGHT}, ctx);
+            this.drawCircle({x: this.x, y: (1 - dt / this.beatmap.approachTime) * Beatmap.HEIGHT - this.beatmap.CATCHER_HEIGHT}, ctx);
+        }
+    }
+};
+PalpableCatchHitObject.prototype.drawCircle = function(position, ctx)
+{
+    ctx.save();
+    ctx.beginPath();
+    ctx.arc(position.x, position.y, this.radius, -Math.PI, Math.PI);
+    ctx.shadowBlur = 0;
+    ctx.fillStyle = this.color;
+    ctx.fill();
+    ctx.restore();
+};
+PalpableCatchHitObject.prototype.drawBanana = function(position, ctx)
+{
+    ctx.save();
+    ctx.beginPath();
+    ctx.shadowBlur = 0;
+    ctx.arc(position.x, position.y, this.radius * 0.9, -Math.PI, Math.PI);
+    ctx.lineWidth = this.radius * 0.2;
+    ctx.strokeStyle = this.color;
+    ctx.stroke();
+    ctx.restore();
+};
+PalpableCatchHitObject.prototype.drawDashCircle = function(position, ctx)
+{
+    ctx.save();
+    ctx.beginPath();
+    ctx.shadowBlur = 0;
+    ctx.arc(position.x, position.y, this.radius * 1.1, -Math.PI, Math.PI);
+    ctx.lineWidth = this.radius * 0.2;
+    ctx.strokeStyle = 'rgb(255,0,0)';
+    ctx.stroke();
+    ctx.restore();
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/catch/bananashower.js

@@ -0,0 +1,33 @@
+function BananaShower(data, beatmap) {
+    Spinner.call(this, data, beatmap);
+
+    this.endTime = data[5] | 0;
+    this.duration = this.endTime - this.time;
+
+    this.nested = [];
+}
+BananaShower.prototype = Object.create(Spinner.prototype);
+BananaShower.prototype.constructor = BananaShower;
+BananaShower.ID = 8;
+Catch.prototype.hitObjectTypes[BananaShower.ID] = BananaShower;
+BananaShower.prototype.buildNested = function() {
+    this.nested = [];
+    let spacing = this.duration;
+    while (spacing > 100) spacing /= 2;
+    if (spacing <= 0) return;
+    let time = this.time;
+    let i = 0;
+    while (time <= this.endTime) {
+        this.nested.push(new PalpableCatchHitObject({
+            type: "Banana",
+            time,
+            x: 0,
+            color: 'rgb(255,240,0)',
+            radius: this.beatmap.bananaRadius,
+        }, this.beatmap));
+
+        time += spacing;
+        i++;
+    }
+    return this;
+};

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

@@ -0,0 +1,211 @@
+function Catch(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 = Catch.DEFAULT_COLORS;
+    }
+
+    this.circleRadius = this.circleDiameter / 2 - 4;
+    this.smallRadius = this.circleRadius / 2;
+    this.tinyRadius = this.smallRadius / 2;
+    this.bananaRadius = this.circleRadius * 0.8;
+
+    this.CATCHER_HEIGHT = Beatmap.HEIGHT / 8;
+    this.FALLOUT_TIME = (this.CATCHER_HEIGHT / Beatmap.HEIGHT) * this.approachTime;
+
+    var combo = 1,
+        comboIndex = -1,
+        setComboIndex = 1;
+    for (var i = 0; i < this.HitObjects.length; i++) {
+        let hitObject = this.HitObjects[i];
+        if (hitObject instanceof BananaShower) {
+            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];
+
+        if (hitObject instanceof JuiceStream || hitObject instanceof BananaShower) {
+            hitObject.buildNested();
+        }
+    }
+
+    this.CATCHER_BASE_SIZE = 106.75;
+    this.ALLOWED_CATCH_RANGE = 0.8;
+    this.HYPER_DASH_TRANSITION_DURATION = 180;
+    this.calculateScale = 1.0 - 0.7 * (this.CircleSize - 5) / 5;
+    this.catchWidth = this.CATCHER_BASE_SIZE * Math.abs(this.calculateScale) * this.ALLOWED_CATCH_RANGE;
+    this.halfCatcherWidth = this.catchWidth / 2;
+    this.halfCatcherWidth /= this.ALLOWED_CATCH_RANGE;
+    this.BASE_DASH_SPEED = 1;
+    this.BASE_WALK_SPEED = 0.5;
+
+    // sliders & spins xoffset
+    this.RNG_SEED = 1337;
+    var rng = new LegacyRandom(this.RNG_SEED);
+
+    for (var i = 0; i < this.HitObjects.length; i++) {
+        let hitObject = this.HitObjects[i];
+        // console.log(hitObject.nested)
+        if (hitObject instanceof BananaShower) {
+            hitObject.nested.forEach(banana => {
+                banana.x += (rng.NextDouble() * Beatmap.MAX_X);
+                rng.Next(); // osu!stable retrieved a random banana type
+                rng.Next(); // osu!stable retrieved a random banana rotation
+                rng.Next(); // osu!stable retrieved a random banana colour
+            });
+        }
+        else if (hitObject instanceof JuiceStream) {
+            hitObject.nested.forEach(item => {
+                if (item.type === "TinyDroplet") item.x += Math.clamp(rng.Next(-20, 20), -item.x, Beatmap.MAX_X - item.x);
+                else if (item.type === "Droplet") rng.Next(); // osu!stable retrieved a random droplet rotation
+            });
+        }
+    }
+
+    // catch objects
+    this.palpableObjects = [];
+    this.fullCatchObjects = [];
+    for (var i = 0; i < this.HitObjects.length; i++) {
+        let hitObject = this.HitObjects[i];
+        if (hitObject instanceof Fruit) {
+            let pch = new PalpableCatchHitObject({
+                type: "Fruit",
+                time: hitObject.time,
+                x: hitObject.position.x,
+                color: hitObject.color,
+                radius: this.circleRadius,
+            }, this);
+
+            this.palpableObjects.push(pch);
+            this.fullCatchObjects.push(pch);
+        }
+        else if (hitObject instanceof BananaShower) {
+            hitObject.nested.forEach(banana => {
+                this.fullCatchObjects.push(banana);
+            });
+        }
+        else if (hitObject instanceof JuiceStream) {
+            hitObject.nested.forEach(item => {
+                this.fullCatchObjects.push(item);
+                if (item.type != "TinyDroplet") this.palpableObjects.push(item);
+            });
+        }
+    }
+
+    this.palpableObjects.sort((a, b) => a.time - b.time);
+    this.fullCatchObjects.sort((a, b) => a.time - b.time);
+
+    // hyperdash
+    let lastDirection = 0;
+    let lastExcess = this.halfCatcherWidth;
+
+    for (let i = 0; i < this.palpableObjects.length - 1; i++) {
+        var currentObject = this.palpableObjects[i];
+        var nextObject = this.palpableObjects[i + 1];
+
+        currentObject.hyperDash = false;
+
+        let thisDirection = nextObject.x > currentObject.x ? 1 : -1;
+        let timeToNext = nextObject.time - currentObject.time - 1000 / 60 / 4; // 1/4th of a frame of grace time, taken from osu-stable
+        let distanceToNext = Math.abs(nextObject.x - currentObject.x) - (lastDirection == thisDirection ? lastExcess : this.halfCatcherWidth);
+        let distanceToHyper = timeToNext * this.BASE_DASH_SPEED - distanceToNext;
+
+        if (distanceToHyper < 0) {
+            currentObject.hyperDash = true;
+            lastExcess = this.halfCatcherWidth;
+        }
+        else {
+            lastExcess = Math.clamp(distanceToHyper, 0, this.halfCatcherWidth);
+        }
+
+        lastDirection = thisDirection;
+    }
+
+}
+Catch.prototype = Object.create(Beatmap.prototype, {
+    approachTime: { // droptime
+        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;
+        }
+    }
+});
+Catch.prototype.constructor = Catch;
+Catch.prototype.hitObjectTypes = {};
+Catch.ID = 2;
+Beatmap.modes[Catch.ID] = Catch;
+Catch.DEFAULT_COLORS = [
+    'rgb(255,210,128)',
+    'rgb(128,255,128)',
+    'rgb(128,191,255)',
+    'rgb(191,128,255)'
+];
+Catch.prototype.update = function (ctx) {
+    ctx.translate((Beatmap.WIDTH - Beatmap.MAX_X) / 2, (Beatmap.HEIGHT - Beatmap.MAX_Y) / 2);
+};
+Catch.prototype.draw = function (time, ctx) {
+    if (typeof this.tmp.first == 'undefined') {
+        this.tmp.first = 0;
+        this.tmp.last = -1;
+    }
+
+    while (this.tmp.first < this.fullCatchObjects.length) {
+        var catchHitObject = this.fullCatchObjects[this.tmp.first];
+        if (time <= catchHitObject.time + this.FALLOUT_TIME) {
+            break;
+        }
+        this.tmp.first++;
+    }
+    while (this.tmp.last + 1 < this.fullCatchObjects.length &&
+        time >= this.fullCatchObjects[this.tmp.last + 1].time - this.approachTime * 1.1) {
+        this.tmp.last++;
+    }
+    for (var i = this.tmp.last; i >= this.tmp.first; i--) {
+        var catchHitObject = this.fullCatchObjects[i];
+        if (time > catchHitObject.time + this.FALLOUT_TIME) {
+            continue;
+        }
+        catchHitObject.draw(time, ctx);
+    }
+};
+Catch.prototype.processBG = function (ctx) {
+    let xoffset = (Beatmap.WIDTH - Beatmap.MAX_X) / 2;
+    let yoffset = (Beatmap.HEIGHT - Beatmap.MAX_Y) / 2;
+    // line
+    ctx.beginPath();
+    ctx.moveTo(-xoffset, Beatmap.HEIGHT - this.CATCHER_HEIGHT - yoffset);
+    ctx.lineTo(Beatmap.WIDTH - xoffset, Beatmap.HEIGHT - this.CATCHER_HEIGHT - yoffset);
+    ctx.strokeStyle = '#fff';
+    ctx.lineWidth = 1;
+    ctx.stroke();
+    // plate
+    let plateHeight = 20;
+    ctx.beginPath();
+    ctx.rect(Beatmap.WIDTH / 2 - this.catchWidth / 2 - xoffset, Beatmap.HEIGHT - this.CATCHER_HEIGHT - plateHeight / 2 - yoffset, this.catchWidth, plateHeight);
+    ctx.strokeStyle = '#fff';
+    ctx.lineWidth = 8;
+    ctx.stroke();
+    ctx.fillStyle = '#fff';
+    ctx.fill();
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/catch/fruit.js

@@ -0,0 +1,21 @@
+function Fruit(data, beatmap)
+{
+    HitObject.call(this, data, beatmap);
+}
+Fruit.prototype = Object.create(HitObject.prototype, {
+    newCombo: {
+        get: function()
+        {
+            return this.flag & 4;
+        }
+    },
+    comboSkip: {
+        get: function()
+        {
+            return this.flag >> 4;
+        }
+    }
+});
+Fruit.prototype.constructor = Fruit;
+Fruit.ID = 1;
+Catch.prototype.hitObjectTypes[Fruit.ID] = Fruit;