PPCC

Pixel Place Compile Client
当前为 2022-04-30 提交的版本，查看最新版本。
此脚本不应直接安装。它是供其他脚本使用的外部库，要使用该库请加入元指令 // @require https://update.gf.qytechs.cn/scripts/443844/1045799/PPCC.js
换行
// ==UserScript==
// @name         PPCC
// @description  Pixel Place Compile Client
// @version      1.6.1
// @author       0vC4
// @namespace    https://gf.qytechs.cn/users/670183
// @match        https://pixelplace.io/*
// @icon         https://www.google.com/s2/favicons?sz=64&domain=pixelplace.io
// @license      MIT
// @grant        none
// @run-at       document-start
// ==/UserScript==





const PPCC = (() => {
    return {
        speed: 30,
        compile(client, PPML, CWSS, timer=window) {
            const speed = this.speed;
            
            Object.assign(client, {
                _id: 0,
                _posSocket: 0,
                sockets: [],
                getSocket() {
                    let i = 0;
                    let ws = null;
                    
                    while (i++ < this.sockets.length) {
                        if (this._posSocket > this.sockets.length-1) this._posSocket = 0;
                        const _ws = this.sockets[this._posSocket++];
                        
                        if (!_ws._can) continue;
                        ws = _ws;
                        break;
                    }
                    
                    return ws;
                },
                
                ws: null,
                map: {},

                onclick: null,

                last: [0, 0, 255],
                lock: false,
                _pixelQueue: [],
                _posQueue: 0,
                _queueId: 0,
                safeEmit(x, y, pixel) {
                    client._pixelQueue.push([client._queueId++, x, y, pixel]);
                }
            });
            
            
            
            let progress = false;
            timer.setInterval(() => {
                if (progress) return;
                progress = true;
                
                while (client._posQueue < client._pixelQueue.length) {
                    const [id, x, y, pixel] = client._pixelQueue[client._posQueue++];
                    if (pixel === 255 || client.map.get(x,y) === 255) continue;
                    if (client.map.get(x,y) === pixel) continue;
                    
                    const ws = client.getSocket();
                    if (!ws) {
                        client._posQueue--;
                        progress = false;
                        return;
                    }
                    
                    CWSS.send.call(ws, `42["p",[${x},${y},${pixel},1]]`);
                    ws._can = false;
                    continue;
                }
                
                if (client.lock && client._posQueue > client._pixelQueue.length-1) {
                    client._posQueue = 0;
                    progress = false;
                    return;
                }
                
                client._posQueue = 0;
                client._pixelQueue = [];
                client._queueId = 0;
                progress = false;
            });



            PPML.onload = map => {
                Object.assign(client.map, map);
                client.map.pixels = new Uint8Array(map.pixels);
            };



            CWSS.setHook({
                priority: 0,
                init() {
                    if (client.ws) return arguments;
                    client.ws = this;
                    return arguments;
                },
                
                open() {
                    client.sockets.push(this);
                    this.id = client._id++;
                    
                    this.addEventListener('close', () => {
                        timer.clearInterval(this._inter);
                        client.sockets.splice(client.sockets.indexOf(this),1);
                    });
                    
                    this._can = true;
                    this._inter = timer.setInterval(() => {
                        this._can = true;
                    }, 1e3/speed);
                    
                    return arguments;
                },

                message({data}) {
                    if (client.ws != this) return arguments;

                    const message = JSON.parse(data.split(/(?<=^\d+)(?=[^\d])/)[1] || '[]');
                    if (!message.length) return arguments;

                    const [event, json] = message;
                    if (event == 'canvas' || event == 'p') json.map(p => client.map.set(...p));

                    return arguments;
                },

                send(data) {
                    if (client.ws != this) return arguments;

                    const message = JSON.parse(data.split(/(?<=^\d+)(?=[^\d])/)[1] || '[]');
                    if (!message.length) return arguments;

                    const [event, json] = message;
                    if (event == 'p') {
                        const [x, y, pixel] = json;
                        client.last = [x, y, pixel];
                        if (client.onclick && client.onclick(x, y, pixel) === false) return;
                    }

                    return arguments;
                }
            });
        }
    };
})();
// 0vC4#7152
欢迎访问Greasy Fork镜像
