☰

PPT

Pixel Place Tools

当前为 2022-05-02 提交的版本，查看 最新版本。

此脚本不应直接安装。它是供其他脚本使用的外部库，要使用该库请加入元指令 // @require https://update.gf.qytechs.cn/scripts/443807/1046393/PPT.js 

  1. // ==UserScript==
  2. // @name         PPT
  3. // @description  Pixel Place Tools
  4. // @version      2.3
  5. // @author       0vC4
  6. // @namespace    https://gf.qytechs.cn/users/670183
  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.  
  15.  
  16.  
  17.  
  18. const PPT = (() => {
  19.     if (window.PPT) return window.PPT;
  20.  
  21.  
  22.  
  23.     const worker = function(func) {
  24.         const worker = new Worker(URL.createObjectURL(new Blob(["onmessage=async({data})=>self.postMessage(await(" + func.toString() + ")(data))"], { type: "text/javascript" })));
  25.         const root = {};
  26.         const post = data => (worker.postMessage(data), root);
  27.         const then = callback => (worker.onmessage=({data})=>callback(data), root);
  28.         return Object.assign(root, {post, then});
  29.     };
  30.  
  31.  
  32.  
  33.     const PPT = {
  34.         zero: 0xCCCCCC,
  35.         default: new Uint32Array([
  36.             0xFFFFFF,
  37.             0xC4C4C4,
  38.             0x888888,
  39.             0x555555,
  40.             0x222222,
  41.             0x000000,
  42.             0x006600,
  43.             0x22B14C,
  44.             0x02BE01,
  45.             0x51E119,
  46.             0x94E044,
  47.             0xFBFF5B,
  48.             0xE5D900,
  49.             0xE6BE0C,
  50.             0xE59500,
  51.             0xA06A42,
  52.             0x99530D,
  53.             0x633C1F,
  54.             0x6B0000,
  55.             0x9F0000,
  56.             0xE50000,
  57.             0xFF3904,
  58.             0xBB4F00,
  59.             0xFF755F,
  60.             0xFFC49F,
  61.             0xFFDFCC,
  62.             0xFFA7D1,
  63.             0xCF6EE4,
  64.             0xEC08EC,
  65.             0x820080,
  66.             0x5100FF,
  67.             0x020763,
  68.             0x0000EA,
  69.             0x044BFF,
  70.             0x6583CF,
  71.             0x36BAFF,
  72.             0x0083C7,
  73.             0x00D3DD,
  74.             0x45FFC8
  75.         ]),
  76.         exclude: new Uint32Array([
  77.             0x51E119,
  78.             0xFF3904,
  79.             0x5100FF,
  80.             0x45FFC8
  81.         ]),
  82.         get palette() {
  83.             return this.default.map(color => this.exclude.includes(color) ? this.zero : color);
  84.         },
  85.  
  86.  
  87.  
  88.         _wheelID: 0,
  89.         get wheel() {
  90.             let pixel = this._wheelID+1;
  91.  
  92.             while (this.palette[pixel] == this.zero)
  93.                 if (this.palette[++pixel] == null)
  94.                     pixel = 0;
  95.  
  96.             this._wheelID = pixel;
  97.             return this._wheelID;
  98.         },
  99.  
  100.  
  101.  
  102.         RGB2P(r, g, b) {
  103.             const closest = [...this.palette]
  104.             .filter(n => n != this.zero)
  105.             .map(clr =>
  106.                 [
  107.                     ((r - ((clr>>16)&0xFF))*.299)**2 +
  108.                     ((g - ((clr>>8)&0xFF))*.587)**2 +
  109.                     ((b - (clr&0xFF))*.114)**2,
  110.                     clr
  111.                 ]
  112.             )
  113.             .sort((a,b) => a[0]-b[0])
  114.             [0][1];
  115.  
  116.             return this.palette.indexOf(closest);
  117.         },
  118.         CLR2P(color) {
  119.             return this.RGB2P((color>>16)&0xFF, (color>>8)&0xFF, color&0xFF);
  120.         },
  121.         
  122.         
  123.         
  124.         client: null,
  125.         get order() {
  126.             if (!this.client) throw new Error('assign client variable first');
  127.             const queue = this.client._pixelQueue;
  128.             
  129.             const [cxn, cyn] = queue.reduce(([x,y], [x2,y2]) => [x+x2,y+y2], [0, 0]);
  130.             const [cx, cy] = [cxn/queue.length>>0, cyn/queue.length>>0];
  131.             
  132.             const workQueue = (func, ...args) => {
  133.                 let fin = queue => 0;
  134.                 const then = finish => finish && (fin = finish);
  135.                 
  136.                 worker(func)
  137.                 .then(queue => fin(this.client._pixelQueue = queue))
  138.                 .post([queue, ...args]);
  139.                 
  140.                 return {then}
  141.             };
  142.             
  143.             return {
  144.                 start(finish){
  145.                     workQueue(([queue]) => {
  146.                         return [...queue].sort(([x,y,p,i], [x2,y2,p2,i2]) => i-i2);
  147.                     }).then(finish);
  148.                 },
  149.                 end(finish){
  150.                     workQueue(([queue]) => {
  151.                         return [...queue].sort(([x,y,p,i], [x2,y2,p2,i2]) => i2-i);
  152.                     }).then(finish);
  153.                 },
  154.                 rand(finish){
  155.                     workQueue(([queue]) => {
  156.                         return [...queue].sort(() => Math.random()-.5);
  157.                     }).then(finish);
  158.                 },
  159.                 
  160.                 top(finish){
  161.                     workQueue(([queue]) => {
  162.                         return [...queue].sort(([x,y], [x2,y2]) => y-y2);
  163.                     }).then(finish);
  164.                 },
  165.                 left(finish){
  166.                     workQueue(([queue]) => {
  167.                         return [...queue].sort(([x,y], [x2,y2]) => x-x2);
  168.                     }).then(finish);
  169.                 },
  170.                 right(finish){
  171.                     workQueue(([queue]) => {
  172.                         return [...queue].sort(([x,y], [x2,y2]) => x2-x);
  173.                     }).then(finish);
  174.                 },
  175.                 bottom(finish){
  176.                     workQueue(([queue]) => {
  177.                         return [...queue].sort(([x,y], [x2,y2]) => y2-y);
  178.                     }).then(finish);
  179.                 },
  180.                 
  181.                 fromCenter(finish){
  182.                     workQueue(([queue, cx, cy]) => {
  183.                         return [...queue].sort(([x,y], [x2,y2]) => 
  184.                             ((x-cx)**2+(y-cy)**2) - 
  185.                             ((x2-cx)**2+(y2-cy)**2)
  186.                         );
  187.                     }, cx, cy).then(finish);
  188.                 },
  189.                 toCenter(finish){
  190.                     workQueue(([queue, cx, cy]) => {
  191.                         return [...queue].sort(([x,y], [x2,y2]) => 
  192.                             ((x2-cx)**2+(y2-cy)**2) - 
  193.                             ((x-cx)**2+(y-cy)**2)
  194.                         );
  195.                     }, cx, cy).then(finish);
  196.                 },
  197.                 
  198.                 fromMapCenter(finish){
  199.                     workQueue(([queue, cx, cy]) => {
  200.                         return [...queue].sort(([x,y], [x2,y2]) => 
  201.                             ((x-cx)**2+(y-cy)**2) - 
  202.                             ((x2-cx)**2+(y2-cy)**2)
  203.                         );
  204.                     }, this.client.map.width/2, this.client.map.height/2).then(finish);
  205.                 },
  206.                 toMapCenter(finish){
  207.                     workQueue(([queue, cx, cy]) => {
  208.                         return [...queue].sort(([x,y], [x2,y2]) => 
  209.                             ((x2-cx)**2+(y2-cy)**2) - 
  210.                             ((x-cx)**2+(y-cy)**2)
  211.                         );
  212.                     }, this.client.map.width/2, this.client.map.height/2).then(finish);
  213.                 },
  214.             };
  215.         },
  216.         
  217.         
  218.         
  219.         timer: window,
  220.         pixel: 0,
  221.         size: 1,
  222.         innerSize: 0,
  223.         speed: 100,
  224.         map: {pixels:[],width:0,height:0,get(x,y){return 255}},
  225.         
  226.         square(x,y, callback, finish) {
  227.             const {pixel, timer, speed, size, innerSize} = this;
  228.             const half = size>>1;
  229.             const innerHalf = innerSize>>1;
  230.             let xi = -half;
  231.             let yi = -half;
  232.             
  233.             let t = timer.setInterval(() => {
  234.                 let i = 0;
  235.                 
  236.                 for (; yi < half+1;) {
  237.                     for (; xi < half+1;) {
  238.                         if (pixel === 255 || xi > -innerHalf && xi < innerHalf && yi > -innerHalf && yi < innerHalf) {
  239.                             xi++;
  240.                             continue;
  241.                         }
  242.                         
  243.                         callback(x+xi, y+yi, pixel, t);
  244.                         xi++;
  245.                         
  246.                         i++;
  247.                         if (i > speed) return;
  248.                         continue;
  249.                     }
  250.                     yi++;
  251.                     xi = -half;
  252.                 }
  253.                 
  254.                 timer.clearInterval(t);
  255.                 finish&&finish();
  256.             });
  257.             
  258.             return t;
  259.         },
  260.         
  261.         
  262.         
  263.         ring(x,y, callback, finish) {
  264.             const {pixel, timer, speed, size, innerSize} = this;
  265.             const half = size>>1;
  266.             const innerHalf = innerSize>>1;
  267.             let xi = -half;
  268.             let yi = -half;
  269.             
  270.             let t = timer.setInterval(() => {
  271.                 let i = 0;
  272.                 
  273.                 for (; yi < half+1;) {
  274.                     for (; xi < half+1;) {
  275.                         if (pixel === 255 || xi**2 + yi**2 > half**2 || xi**2 + yi**2 < innerHalf**2) {
  276.                             xi++;
  277.                             continue;
  278.                         }
  279.                         
  280.                         callback(x+xi, y+yi, pixel, t);
  281.                         xi++;
  282.                         
  283.                         i++;
  284.                         if (i > speed) return;
  285.                         continue;
  286.                     }
  287.                     yi++;
  288.                     xi = -half;
  289.                 }
  290.                 
  291.                 timer.clearInterval(t);
  292.                 finish&&finish();
  293.             });
  294.             
  295.             return t;
  296.         },
  297.         
  298.         
  299.         
  300.         shader(callback, finish) {
  301.             const {timer, speed, map} = this;
  302.             let pos = 0;
  303.             
  304.             let t = timer.setInterval(() => {
  305.                 let i = 0;
  306.                 
  307.                 for (; pos < map.pixels.length; ) {
  308.                     if (map.pixels[pos] === 255) {
  309.                         pos++;
  310.                         continue;
  311.                     }
  312.                     
  313.                     callback(pos%map.width, pos/map.width>>0, map.pixels[pos], t);
  314.                     pos++;
  315.                     
  316.                     i++;
  317.                     if (i > speed) return;
  318.                     continue;
  319.                 }
  320.                 
  321.                 timer.clearInterval(t);
  322.                 finish&&finish();
  323.             });
  324.             
  325.             return t;
  326.         },
  327.         
  328.         
  329.         
  330.         image(pixels, x,y,w,h, callback, finish) {
  331.             const {timer, speed} = this;
  332.             let xi = 0;
  333.             let yi = 0;
  334.             
  335.             let t = timer.setInterval(() => {
  336.                 let i = 0;
  337.                 
  338.                 for (; yi < h;) {
  339.                     for (; xi < w;) {
  340.                         const pixel = pixels[xi+yi*w];
  341.                         
  342.                         if (pixel === 255) {
  343.                             xi++;
  344.                             continue;
  345.                         }
  346.                         
  347.                         callback(x+xi, y+yi, pixel, t);
  348.                         xi++;
  349.                         
  350.                         i++;
  351.                         if (i > speed) return;
  352.                         continue;
  353.                     }
  354.                     yi++;
  355.                     xi = 0;
  356.                 }
  357.                 
  358.                 timer.clearInterval(t);
  359.                 finish&&finish();
  360.             });
  361.             
  362.             return t;
  363.         }
  364.     };
  365.  
  366.  
  367.  
  368.     window.PPT = PPT;
  369.     return PPT;
  370. })();
  371. // 0vC4#7152

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

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

加入Q群

QingJ © 2025

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