☰

MyBot Tools

MyBot Pixel Place Tools

此腳本不應該直接安裝，它是一個供其他腳本使用的函式庫。欲使用本函式庫，請在腳本 metadata 寫上： // @require https://update.gf.qytechs.cn/scripts/479130/1275795/MyBot%20Tools.js 

  1. // ==UserScript==
  2. // @name         MyBot Tools
  3. // @description  MyBot Pixel Place Tools
  4. // @version      1.6.2
  5. // @author       SamaelWired
  6. // @namespace    https://gf.qytechs.cn/tr/users/976572
  7. // @match        https://pixelplace.io/*
  8. // @icon         https://www.google.com/s2/favicons?sz=64&domain=pixelplace.io
  9. // @license      MIT
  10. // @grant        none
  11. // @run-at       document-start
  12. // ==/UserScript==
  13. (() => {
  14.     const MyBot = window.MyBot || { modules: {} };
  15.     window.MyBot = MyBot;
  16.     if ('Tools' in MyBot.modules) return;
  17.  
  18.     const progressManager = func => {
  19.         const callbacks = {};
  20.         const root = new Proxy({}, {
  21.             get(target, key) {
  22.                 if (!target[key]) target[key] = callback => (callbacks[key] = callback, root);
  23.                 return target[key];
  24.             }
  25.         });
  26.         root.start = (...args) => func(callbacks)(...args);
  27.         return root;
  28.     };
  29.  
  30.     const worker = progressManager(({ progress = () => 0, finish = () => 0 }) =>
  31.         (data, func) => {
  32.             const worker = new Worker(URL.createObjectURL(new Blob([`
  33.             const progress = value => self.postMessage({ progress: true, value });
  34.             const finish = value => self.postMessage({ finish: true, value });
  35.             onmessage = async ({ data }) => {
  36.                 await (${func.toString()})(data);
  37.                 close();
  38.             };
  39.         `], { type: "text/javascript" })));
  40.             worker.addEventListener('message', ({ data }) => data.progress && progress(data.value));
  41.             worker.addEventListener('message', ({ data }) => data.finish && finish(data.value));
  42.             worker.postMessage(data);
  43.         });
  44.  
  45.     const module = {
  46.         args: {},
  47.  
  48.         _wheelID: 0,
  49.         get wheel() {
  50.             const { exclude, colors } = module.args;
  51.             let pixel = module._wheelID + 1;
  52.             while (exclude.includes(colors[pixel]))
  53.                 if (colors[++pixel] == null)
  54.                     pixel = 0;
  55.             module._wheelID = pixel;
  56.             return pixel;
  57.         },
  58.  
  59.         pixel: 0,
  60.         size: 9,
  61.         innerSize: 0,
  62.         interval: 0,
  63.  
  64.         RGB2P(r, g, b) {
  65.             const closest = module.args.rgb.map(([r2, g2, b2]) =>
  66.                 ((r2 - r) ** 2 + (g2 - g) ** 2 + (b2 - b) ** 2) * 0x1000000 + (r2 << 16) + (g2 << 8) + b
  67.             )
  68.                 .sort((a, b) => a - b)[0];
  69.  
  70.             return module.args.colors.indexOf(closest & 0xFFFFFF);
  71.         },
  72.         CLR2P(color) {
  73.             return module.RGB2P((color >> 16) & 0xFF, (color >> 8) & 0xFF, color & 0xFF);
  74.         },
  75.     };
  76.  
  77.     module.config = ({ colors, exclude, zero, timer, tickSpeed }) => {
  78.         const palette = [...colors].map(color => exclude.includes(color) ? zero : color);
  79.         const rgb = palette.filter(clr => clr != zero).map(clr => [((clr >> 16) & 0xFF), ((clr >> 8) & 0xFF), (clr & 0xFF)]);
  80.         Object.assign(module.args, { colors, exclude, zero, timer, tickSpeed, palette, rgb });
  81.     };
  82.  
  83.     module.shader = progressManager(({
  84.         progress = () => 0, finish = () => 0, tick = () => 0,
  85.         silent = true,
  86.         interval = module.interval
  87.     }) => (map) => {
  88.         const { timer } = module.args;
  89.         let pos = 0;
  90.  
  91.         let t = timer.setInterval(() => {
  92.             const { tickSpeed } = module.args;
  93.             let i = 0;
  94.  
  95.             for (; pos < map.pixels.length;) {
  96.                 silent || progress(pos / map.pixels.length, t);
  97.                 if (map.pixels[pos] === 255) {
  98.                     pos++;
  99.                     continue;
  100.                 }
  101.  
  102.                 tick(pos % map.width, pos / map.width >> 0, map.pixels[pos]);
  103.                 pos++;
  104.  
  105.                 i++;
  106.                 if (i > tickSpeed) return;
  107.                 continue;
  108.             }
  109.  
  110.             timer.clearInterval(t);
  111.             finish(t);
  112.         }, interval);
  113.  
  114.         return t;
  115.     });
  116.  
  117.     module.square = progressManager(({
  118.         progress = () => 0, finish = () => 0, tick = () => 0,
  119.         silent = true,
  120.         interval = module.interval,
  121.         size = module.size,
  122.         innerSize = module.innerSize,
  123.     }) => (x, y, pixel = module.pixel) => {
  124.         const { timer } = module.args;
  125.         const half = size >> 1;
  126.         const innerHalf = innerSize >> 1;
  127.         let xi = -half;
  128.         let yi = -half;
  129.  
  130.         let t = timer.setInterval(() => {
  131.             const { tickSpeed } = module.args;
  132.             let i = 0;
  133.  
  134.             for (; yi < half + 1;) {
  135.                 for (; xi < half + 1;) {
  136.                     const pos = (xi + half + (yi + half) * size);
  137.                     silent || progress(pos / size ** 2, t);
  138.  
  139.                     if (pixel === 255 || xi > -innerHalf && xi < innerHalf && yi > -innerHalf && yi < innerHalf) {
  140.                         xi++;
  141.                         continue;
  142.                     }
  143.  
  144.                     tick(x + xi, y + yi, pixel);
  145.                     xi++;
  146.  
  147.                     i++;
  148.                     if (i > tickSpeed) return;
  149.                     continue;
  150.                 }
  151.                 yi++;
  152.                 xi = -half;
  153.             }
  154.  
  155.             timer.clearInterval(t);
  156.             finish(t);
  157.         }, interval);
  158.  
  159.         return t;
  160.     });
  161.  
  162.     module.circle = progressManager(({
  163.         progress = () => 0, finish = () => 0, tick = () => 0,
  164.         silent = true,
  165.         interval = module.interval,
  166.         radius = module.size >> 1,
  167.         innerRadius = module.innerSize >> 1,
  168.     }) => (x, y, pixel = module.pixel) => {
  169.         const { timer } = module.args;
  170.         const half = radius;
  171.         const innerHalf = innerRadius;
  172.         let xi = -half;
  173.         let yi = -half;
  174.  
  175.         let t = timer.setInterval(() => {
  176.             const { tickSpeed } = module.args;
  177.             let i = 0;
  178.  
  179.             for (; yi < half + 1;) {
  180.                 for (; xi < half + 1;) {
  181.                     const pos = (xi + half + (yi + half) * size);
  182.                     silent || progress(pos / size ** 2, t);
  183.  
  184.                     if (pixel === 255 || xi ** 2 + yi ** 2 > half ** 2 || xi ** 2 + yi ** 2 < innerHalf ** 2) {
  185.                         xi++;
  186.                         continue;
  187.                     }
  188.  
  189.                     tick(x + xi, y + yi, pixel);
  190.                     xi++;
  191.  
  192.                     i++;
  193.                     if (i > tickSpeed) return;
  194.                     continue;
  195.                 }
  196.                 yi++;
  197.                 xi = -half;
  198.             }
  199.  
  200.             timer.clearInterval(t);
  201.             finish(t);
  202.         }, interval);
  203.  
  204.         return t;
  205.     });
  206.  
  207.     module.image = progressManager(({
  208.         progress = () => 0, finish = () => 0, tick = () => 0,
  209.         interval = module.interval,
  210.     }) => (pixels, x, y, w, h) => {
  211.         const { timer } = module.args;
  212.         let xi = 0;
  213.         let yi = 0;
  214.  
  215.         let t = timer.setInterval(() => {
  216.             const { tickSpeed } = module.args;
  217.             let i = 0;
  218.  
  219.             for (; yi < h;) {
  220.                 for (; xi < w;) {
  221.                     const pos = xi + yi * w;
  222.                     progress(pos / pixels.length, t);
  223.  
  224.                     const pixel = pixels[pos];
  225.                     if (pixel === 255) {
  226.                         xi++;
  227.                         continue;
  228.                     }
  229.  
  230.                     tick(x + xi, y + yi, pixel);
  231.                     xi++;
  232.  
  233.                     i++;
  234.                     if (i > tickSpeed) return;
  235.                     continue;
  236.                 }
  237.                 yi++;
  238.                 xi = 0;
  239.             }
  240.  
  241.             timer.clearInterval(t);
  242.             finish(t);
  243.         }, interval);
  244.  
  245.         return t;
  246.     });
  247.  
  248.     module.order = new Proxy({}, {
  249.         get(_, type) {
  250.             return progressManager(({
  251.                 progress = () => 0, finish = () => 0,
  252.                 silent = true,
  253.                 center = [0, 0]
  254.             }) => (queue) => {
  255.                 if (type == 'fromCenterQueue' || type == 'toCenterQueue') {
  256.                     type = type.replace('Queue', '');
  257.                     const [cxn, cyn] = queue.reduce(([x, y], [x2, y2]) => [x + x2, y + y2], [0, 0]);
  258.                     center = [cxn / queue.length >> 0, cyn / queue.length >> 0];
  259.                 }
  260.                 worker.progress(progress).finish(finish)
  261.                     .start(
  262.                         { queue, type, center, silent },
  263.                         async ({ queue, type, center, silent }) => {
  264.                             const q = [...queue];
  265.                             const size = queue.length * Math.log(queue.length) | 0;
  266.                             const [cx, cy] = center;
  267.                             let i = 0;
  268.  
  269.                             const method = ({
  270.                                 start([x, y, p, i], [x2, y2, p2, i2]) {
  271.                                     silent || progress(i++ / size);
  272.                                     return i - i2;
  273.                                 },
  274.                                 end([x, y, p, i], [x2, y2, p2, i2]) {
  275.                                     silent || progress(i++ / size);
  276.                                     return i2 - i;
  277.                                 },
  278.                                 rand() {
  279.                                     silent || progress(i++ / size);
  280.                                     return Math.random() - .5;
  281.                                 },
  282.  
  283.                                 top([x, y], [x2, y2]) {
  284.                                     silent || progress(i++ / size);
  285.                                     return y - y2;
  286.                                 },
  287.                                 left([x, y], [x2, y2]) {
  288.                                     silent || progress(i++ / size);
  289.                                     return x - x2;
  290.                                 },
  291.                                 right([x, y], [x2, y2]) {
  292.                                     silent || progress(i++ / size);
  293.                                     return x2 - x;
  294.                                 },
  295.                                 bottom([x, y], [x2, y2]) {
  296.                                     silent || progress(i++ / size);
  297.                                     return y2 - y;
  298.                                 },
  299.  
  300.                                 fromCenter([x, y], [x2, y2]) {
  301.                                     silent || progress(i++ / size);
  302.                                     return ((x - cx) ** 2 + (y - cy) ** 2) - ((x2 - cx) ** 2 + (y2 - cy) ** 2);
  303.                                 },
  304.                                 toCenter([x, y], [x2, y2]) {
  305.                                     silent || progress(i++ / size);
  306.                                     return ((x2 - cx) ** 2 + (y2 - cy) ** 2) - ((x - cx) ** 2 + (y - cy) ** 2);
  307.                                 },
  308.  
  309.                                 fromVertical([x, y], [x2, y2]) {
  310.                                     silent || progress(i++ / size);
  311.                                     return Math.abs(x - cx) - Math.abs(x2 - cx);
  312.                                 },
  313.                                 toVertical([x, y], [x2, y2]) {
  314.                                     silent || progress(i++ / size);
  315.                                     return Math.abs(x2 - cx) - Math.abs(x - cx);
  316.                                 },
  317.  
  318.                                 fromHorizontal([x, y], [x2, y2]) {
  319.                                     silent || progress(i++ / size);
  320.                                     return Math.abs(y - cy) - Math.abs(y2 - cy);
  321.                                 },
  322.                                 toHorizontal([x, y], [x2, y2]) {
  323.                                     silent || progress(i++ / size);
  324.                                     return Math.abs(y2 - cy) - Math.abs(y - cy);
  325.                                 },
  326.                             });
  327.  
  328.                             q.sort(method[type] || method['start']);
  329.                             silent || progress(1);
  330.                             finish(q);
  331.                         }
  332.                     );
  333.             });
  334.         }
  335.     });
  336.  
  337.     MyBot.modules.Tools = module;
  338. })();

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址