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

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

@@ -0,0 +1,211 @@
+function Beatmap(osu)
+{
+    // for temporary vars that need for drawing
+    this.tmp = {};
+
+    // [General]
+    this.StackLeniency = 0.7;
+    this.PreviewTime = -1;
+
+    // [Metadata]
+    this.Title = '';
+    this.TitleUnicode = undefined;
+    this.Artist = '';
+    this.ArtistUnicode = undefined;
+    this.Creator = '';
+    this.Version = undefined;
+
+    // [Difficulty]
+    this.CircleSize = 5;
+    this.OverallDifficulty = 5;
+    this.ApproachRate = undefined;
+    this.SliderMultiplier = 1.4;
+    this.SliderTickRate = 1;
+
+    // [TimingPoints]
+    this.TimingPoints = [];
+
+    // [Colours]
+    this.Colors = [];
+
+    // [HitObjects]
+    this.HitObjects = [];
+
+
+    var stream = osu.replace(/\r\n?/g, '\n').split('\n').reverse(),
+        currentSection, line;
+    while (typeof (line = stream.pop()) != 'undefined')
+    {
+        // skip comments
+        if (/^\/\//.test(line))
+        {
+            continue;
+        }
+
+        if (/^\[/.test(line))
+        {
+            currentSection = line.slice(1, line.indexOf(']'));
+            continue;
+        }
+
+        switch (currentSection)
+        {
+            case 'General':
+            case 'Metadata':
+            case 'Difficulty':
+            {
+                // let [key, ...value] = line.split(':');
+                var data = line.split(':'),
+                    key = data.shift(),
+                    value = data.join(':');
+                if (key in this)
+                {
+                    this[key] = parseFloat(value) == value ? +value : value;
+                }
+                break;
+            }
+            case 'TimingPoints':
+            {
+                try
+                {
+                    this.TimingPoints.push(new TimingPoint(line));
+                }
+                catch (e) {}
+                break;
+            }
+            case 'Colours':
+            {
+                // let [key, value] = line.split(':');
+                var data = line.split(':');
+                if (/^Combo\d+/.test(data[0]))
+                {
+                    this.Colors.push('rgb(' + data[1] + ')');
+                }
+                break;
+            }
+            case 'HitObjects':
+            {
+                try
+                {
+                    this.HitObjects.push(HitObject.parse(line, this));
+                }
+                catch (e) { console.log(e); }
+                break;
+            }
+        }
+    }
+    this.HitObjects.sort((a, b) => a.time - b.time);
+}
+Object.defineProperties(Beatmap.prototype, {
+    Version: {
+        get: function()
+        {
+            return typeof this._Version == 'undefined' || /^$/.test(this._Version)
+                ? 'Normal'
+                : this._Version;
+        },
+        set: function(value)
+        {
+            this._Version = value;
+        }
+    },
+    ApproachRate: {
+        get: function()
+        {
+            return typeof this._ApproachRate == 'undefined'
+                ? this.OverallDifficulty
+                : this._ApproachRate;
+        },
+        set: function(value)
+        {
+            this._ApproachRate = value;
+        }
+    },
+    hitObjectTypeMask: {
+        get: function()
+        {
+            if (typeof this._hitObjectTypeMask == 'undefined')
+            {
+                this._hitObjectTypeMask = Object.keys(this.hitObjectTypes).reduce(function(a, b)
+                {
+                    return a | b;
+                });
+            }
+            return this._hitObjectTypeMask;
+        }
+    }
+});
+Beatmap.prototype.hitObjectTypes = undefined;
+Beatmap.prototype.update = undefined;
+Beatmap.prototype.draw = undefined;
+Beatmap.prototype.processBG = undefined;
+Beatmap.WIDTH = 640;
+Beatmap.HEIGHT = 480;
+Beatmap.MAX_X = 512;
+Beatmap.MAX_Y = 384;
+Beatmap.modes = {};
+Beatmap.parse = function(osu)
+{
+    if (!/^osu/.test(osu))
+    {
+        throw 'target is not a beatmap file';
+    }
+
+    // default mode is standard(id: 0)
+    var mode = +((osu.match(/[\r\n]Mode.*?:(.*?)[\r\n]/) || [])[1]) || 0;
+    if (!(mode in Beatmap.modes))
+    {
+        throw 'we do not support this beatmap mode';
+    }
+
+    return new Beatmap.modes[mode](osu);
+};
+Beatmap.prototype.timingPointIndexAt = function(time)
+{
+    var begin = 0,
+        end = this.TimingPoints.length - 1;
+    while (begin <= end)
+    {
+        var mid = (begin + end) / 2 | 0;
+        if (time >= this.TimingPoints[mid].time)
+        {
+            if (mid + 1 == this.TimingPoints.length ||
+                time < this.TimingPoints[mid + 1].time)
+            {
+                return mid;
+            }
+            begin = mid + 1;
+        }
+        else
+        {
+            end = mid - 1;
+        }
+    }
+    return 0;
+};
+Beatmap.prototype.timingPointAt = function(time)
+{
+    return this.TimingPoints[this.timingPointIndexAt(time)];
+};
+Beatmap.prototype.refresh = function()
+{
+    this.tmp = {};
+};
+Beatmap.prototype.toString = function()
+{
+    var unicode = JSON.parse(localStorage['osu_tool'] || '{"unicode":false}')['unicode'];
+    return [
+        (unicode ?
+            [
+                this.ArtistUnicode || this.Artist,
+                this.TitleUnicode || this.Title
+            ] :
+            [
+                this.Artist,
+                this.Title
+            ]
+        ).join(' - '),
+        ' (', this.Creator, ')',
+        ' [', this.Version || 'Normal' , ']'
+    ].join('');
+};

nonebot_plugin_osubot/draw/osu_preview_templates/js/beatmap/hitobject.js

@@ -0,0 +1,29 @@
+function HitObject(data, beatmap)
+{
+    this.beatmap = beatmap;
+
+    this.position = new Point(data);
+    this.endPosition = this.position.clone();
+    this.time = data[2] | 0;
+    this.endTime = this.time;
+    this.flag = data[3] | 0;
+    this.hitSound = data[4] | 0;
+}
+HitObject.prototype.draw = undefined;
+HitObject.parse = function(line, beatmap)
+{
+    var data = line.split(',');
+    if (data.length < 5)
+    {
+        throw 'invalid data: ' + line;
+    }
+
+    var type = data[3] & beatmap.hitObjectTypeMask;
+    if (!(type in beatmap.hitObjectTypes))
+    {
+        // throw 'we do not support this hitobject type';
+        return new HitObject(data, beatmap);
+    }
+
+    return new beatmap.hitObjectTypes[type](data, beatmap);
+};

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;
+};