☰

PPT

Pixel Place Tools

此脚本不应直接安装，它是一个供其他脚本使用的外部库。如果您需要使用该库，请在脚本元属性加入：// @require https://update.cn-greasyfork.org/scripts/443807/1050374/PPT.js 

  1. // ==UserScript==
  2. // @name         PPT
  3. // @description  Pixel Place Tools
  4. // @version      1.6.2
  5. // @author       0vC4
  6. // @namespace    https://greasyfork.org/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.     const PPClient = window.PPClient || {modules:{}};
  15.     window.PPClient = PPClient;
  16.     if ('Tools' in PPClient.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.  
  84.  
  85.     module.shader = progressManager(({
  86.         progress=()=>0, finish=()=>0, tick=()=>0,
  87.         silent=true,
  88.         interval=module.interval
  89.     }) => (map) => {
  90.         const {timer} = module.args;
  91.         let pos = 0;
  92.         
  93.         let t = timer.setInterval(() => {
  94.             const {tickSpeed} = module.args;
  95.             let i = 0;
  96.             
  97.             for (; pos < map.pixels.length; ) {
  98.                 silent || progress(pos/map.pixels.length, t);
  99.                 if (map.pixels[pos] === 255) {
  100.                     pos++;
  101.                     continue;
  102.                 }
  103.                 
  104.                 tick(pos%map.width, pos/map.width>>0, map.pixels[pos]);
  105.                 pos++;
  106.                 
  107.                 i++;
  108.                 if (i > tickSpeed) return;
  109.                 continue;
  110.             }
  111.             
  112.             timer.clearInterval(t);
  113.             finish(t);
  114.         }, interval);
  115.         
  116.         return t;
  117.     });
  118.  
  119.  
  120.  
  121.     module.square = progressManager(({
  122.         progress=()=>0, finish=()=>0, tick=()=>0,
  123.         silent=true,
  124.         interval=module.interval,
  125.         size=module.size,
  126.         innerSize=module.innerSize,
  127.     }) => (x,y,pixel=module.pixel) => {
  128.         const {timer} = module.args;
  129.         const half = size>>1;
  130.         const innerHalf = innerSize>>1;
  131.         let xi = -half;
  132.         let yi = -half;
  133.         
  134.         let t = timer.setInterval(() => {
  135.             const {tickSpeed} = module.args;
  136.             let i = 0;
  137.             
  138.             for (; yi < half+1;) {
  139.                 for (; xi < half+1;) {
  140.                     const pos = (xi+half+(yi+half)*size);
  141.                     silent || progress(pos/size**2, t);
  142.  
  143.                     if (pixel === 255 || xi > -innerHalf && xi < innerHalf && yi > -innerHalf && yi < innerHalf) {
  144.                         xi++;
  145.                         continue;
  146.                     }
  147.                     
  148.                     tick(x+xi, y+yi, pixel);
  149.                     xi++;
  150.                     
  151.                     i++;
  152.                     if (i > tickSpeed) return;
  153.                     continue;
  154.                 }
  155.                 yi++;
  156.                 xi = -half;
  157.             }
  158.             
  159.             timer.clearInterval(t);
  160.             finish(t);
  161.         }, interval);
  162.         
  163.         return t;
  164.     });
  165.  
  166.  
  167.  
  168.     module.circle = progressManager(({
  169.         progress=()=>0, finish=()=>0, tick=()=>0,
  170.         silent=true,
  171.         interval=module.interval,
  172.         radius=module.size>>1,
  173.         innerRadius=module.innerSize>>1,
  174.     }) => (x,y,pixel=module.pixel) => {
  175.         const {timer} = module.args;
  176.         const half = radius;
  177.         const innerHalf = innerRadius;
  178.         let xi = -half;
  179.         let yi = -half;
  180.         
  181.         let t = timer.setInterval(() => {
  182.             const {tickSpeed} = module.args;
  183.             let i = 0;
  184.             
  185.             for (; yi < half+1;) {
  186.                 for (; xi < half+1;) {
  187.                     const pos = (xi+half+(yi+half)*size);
  188.                     silent || progress(pos/size**2, t);
  189.  
  190.                     if (pixel === 255 || xi**2 + yi**2 > half**2 || xi**2 + yi**2 < innerHalf**2) {
  191.                         xi++;
  192.                         continue;
  193.                     }
  194.                     
  195.                     tick(x+xi, y+yi, pixel);
  196.                     xi++;
  197.                     
  198.                     i++;
  199.                     if (i > tickSpeed) return;
  200.                     continue;
  201.                 }
  202.                 yi++;
  203.                 xi = -half;
  204.             }
  205.             
  206.             timer.clearInterval(t);
  207.             finish(t);
  208.         }, interval);
  209.         
  210.         return t;
  211.     });
  212.  
  213.  
  214.  
  215.     module.image = progressManager(({
  216.         progress=()=>0, finish=()=>0, tick=()=>0,
  217.         interval=module.interval,
  218.     }) => (pixels, x,y,w,h) => {
  219.         const {timer} = module.args;
  220.         let xi = 0;
  221.         let yi = 0;
  222.         
  223.         let t = timer.setInterval(() => {
  224.             const {tickSpeed} = module.args;
  225.             let i = 0;
  226.             
  227.             for (; yi < h;) {
  228.                 for (; xi < w;) {
  229.                     const pos = xi+yi*w;
  230.                     progress(pos/pixels.length, t);
  231.  
  232.                     const pixel = pixels[pos];
  233.                     if (pixel === 255) {
  234.                         xi++;
  235.                         continue;
  236.                     }
  237.                     
  238.                     tick(x+xi, y+yi, pixel);
  239.                     xi++;
  240.                     
  241.                     i++;
  242.                     if (i > tickSpeed) return;
  243.                     continue;
  244.                 }
  245.                 yi++;
  246.                 xi = 0;
  247.             }
  248.             
  249.             timer.clearInterval(t);
  250.             finish(t);
  251.         }, interval);
  252.         
  253.         return t;
  254.     });
  255.  
  256.  
  257.  
  258.     module.order = new Proxy({}, {
  259.         get(_, type) {
  260.             return progressManager(({
  261.                 progress=()=>0, finish=()=>0,
  262.                 silent=true,
  263.                 center=[0,0]
  264.             }) => (queue) => {
  265.                 if (type == 'fromCenterQueue' || type == 'toCenterQueue') {
  266.                     type = type.replace('Queue', '');
  267.                     const [cxn, cyn] = queue.reduce(([x,y], [x2,y2]) => [x+x2,y+y2], [0, 0]);
  268.                     center = [cxn/queue.length>>0, cyn/queue.length>>0];
  269.                 }
  270.                 worker.progress(progress).finish(finish)
  271.                 .start(
  272.                     {queue, type, center, silent},
  273.                     async ({queue, type, center, silent}) => {
  274.                         const q = [...queue];
  275.                         const size = queue.length*Math.log(queue.length)|0;
  276.                         const [cx, cy] = center;
  277.                         let i = 0;
  278.  
  279.                         const method = ({
  280.                             start([x,y,p,i], [x2,y2,p2,i2]) {
  281.                                 silent || progress(i++/size);
  282.                                 return i-i2;
  283.                             },
  284.                             end([x,y,p,i], [x2,y2,p2,i2]) {
  285.                                 silent || progress(i++/size);
  286.                                 return i2-i;
  287.                             },
  288.                             rand() {
  289.                                 silent || progress(i++/size);
  290.                                 return Math.random()-.5;
  291.                             },
  292.  
  293.                             top([x,y], [x2,y2]){
  294.                                 silent || progress(i++/size);
  295.                                 return y-y2;
  296.                             },
  297.                             left([x,y], [x2,y2]){
  298.                                 silent || progress(i++/size);
  299.                                 return x-x2;
  300.                             },
  301.                             right([x,y], [x2,y2]){
  302.                                 silent || progress(i++/size);
  303.                                 return x2-x;
  304.                             },
  305.                             bottom([x,y], [x2,y2]){
  306.                                 silent || progress(i++/size);
  307.                                 return y2-y;
  308.                             },
  309.  
  310.                             fromCenter([x,y], [x2,y2]) {
  311.                                 silent || progress(i++/size);
  312.                                 return ((x-cx)**2+(y-cy)**2) - ((x2-cx)**2+(y2-cy)**2);
  313.                             },
  314.                             toCenter([x,y], [x2,y2]) {
  315.                                 silent || progress(i++/size);
  316.                                 return ((x2-cx)**2+(y2-cy)**2) - ((x-cx)**2+(y-cy)**2);
  317.                             },
  318.  
  319.                             fromVertical([x,y], [x2,y2]) {
  320.                                 silent || progress(i++/size);
  321.                                 return Math.abs(x-cx) - Math.abs(x2-cx);
  322.                             },
  323.                             toVertical([x,y], [x2,y2]) {
  324.                                 silent || progress(i++/size);
  325.                                 return Math.abs(x2-cx) - Math.abs(x-cx);
  326.                             },
  327.  
  328.                             fromHorizontal([x,y], [x2,y2]) {
  329.                                 silent || progress(i++/size);
  330.                                 return Math.abs(y-cy) - Math.abs(y2-cy);
  331.                             },
  332.                             toHorizontal([x,y], [x2,y2]) {
  333.                                 silent || progress(i++/size);
  334.                                 return Math.abs(y2-cy) - Math.abs(y-cy);
  335.                             },
  336.                         });
  337.                         
  338.                         q.sort(method[type] || method['start']);
  339.                         silent || progress(1);
  340.                         finish(q);
  341.                     }
  342.                 );
  343.             });
  344.         }
  345.     });
  346.  
  347.  
  348.  
  349.     PPClient.modules.Tools = module;
  350. })();
  351. // 0vC4#7152