Untitled

mail@pastecode.io avatarunknown
plain_text
2 months ago
24 kB
1
Indexable
Never
// ==UserScript==
// @name         BABAPRO LİBRARY
// @namespace    babapro
// @version      1.0
// @description  LİBRARY FOR BABAPRO
// @author       @shigerusensei
// @match        https://pixelplace.io/*
// @icon         https://www.google.com/s2/favicons?sz=64&domain=pixelplace.io
// @grant        unsafeWindow
// @require      https://tinyurl.com/B2B2APR0LIBRY

/* globals unsafeWindow*/
/*jshint esversion: 11 */

Object.defineProperty(unsafeWindow, "console", {
    value: console,
    writable: false,
  });
  class BabaProLoggerFactory {
    static TEMPLATE = "%c[BabaProCore] %s: %s";
    static CSS_INFO = "color:green";
    static CSS_WARNING = "color:yellow;";
    static CSS_ERROR = "color:red;font-weight: bold;";
    static TEMPLATE_INFO = "INFO";
    static TEMPLATE_WARNING = "WARNING";
    static TEMPLATE_ERROR = "ERROR";
    static LEVEL_INFO = 0;
    static LEVEL_WARNING = 1;
    static LEVEL_ERROR = 2;
    LEVEL = BabaProLoggerFactory.LEVEL_INFO;
    constructor() {
      this.listeners = [];
      this.listeners.push(function (template, css, level, msg) {
        console.log(template, css, level, msg);
      });
    }
    dispatch(template, css, level, msg) {
      this.listeners.forEach((listener) => {
        listener(template, css, level, msg);
      });
    }
    info(msg) {
      if (this.LEVEL <= BabaProLoggerFactory.LEVEL_INFO) {
        this.dispatch(
          BabaProLoggerFactory.TEMPLATE,
          BabaProLoggerFactory.CSS_INFO,
          BabaProLoggerFactory.TEMPLATE_INFO,
          msg
        );
      }
    }
    warning(msg) {
      if (this.LEVEL <= BabaProLoggerFactory.LEVEL_WARNING) {
        this.dispatch(
          BabaProLoggerFactory.TEMPLATE,
          BabaProLoggerFactory.CSS_WARNING,
          BabaProLoggerFactory.TEMPLATE_WARNING,
          msg
        );
      }
    }
    error(msg) {
      if (this.LEVEL <= BabaProLoggerFactory.LEVEL_ERROR) {
        this.dispatch(
          BabaProLoggerFactory.TEMPLATE,
          BabaProLoggerFactory.CSS_ERROR,
          BabaProLoggerFactory.TEMPLATE_ERROR,
          msg
        );
        throw Error(msg);
      }
    }
  }

  class BabaProImageConverter {
      static getClosestColor(r, g, b, palette) {
          let closestColor = {r: 0, g: 0, b: 0};
          let closestDistance = Number.MAX_VALUE;
          for (let i = 0;i < palette.colors.length; i++) {
              let bigint = palette.colors[i];
              let p_r = (bigint >> 16) & 255;
              let p_g = (bigint >> 8) & 255;
              let p_b = bigint & 255;
              let distance = (r - p_r)**2 + (g - p_g)**2 + (b - p_b)**2;
              if (distance < closestDistance) {
                  closestColor = {r: p_r, g: p_g, b: p_b};
                  closestDistance = distance;
              }
          }
          return closestColor;
      }
      static floydSteinberg(img_data, w, h, palette) {
          if (unsafeWindow.YURIBOT_DO_NOT_DITHER === true) {
              return img_data;
          }
          let dithered = new Uint8ClampedArray(img_data.data);
          let error_matrix = new Float32Array(w * h * 4);
          for (let y = 0; y < h; y++) {
              for (let x = 0;x < w; x++) {
                  let i = (y * w + x) * 4;
                  let r = img_data.data[i] + error_matrix[i];
                  let g = img_data.data[i + 1] + error_matrix[i + 1];
                  let b = img_data.data[i + 2] + error_matrix[i + 2];
                  let closest = BabaProImageConverter.getClosestColor(r, g, b, palette);
                  dithered[i] = closest.r;
                  dithered[i + 1] = closest.g;
                  dithered[i + 2] = closest.b;
                  dithered[i + 3] = img_data.data[i + 3];
                  let err_r = r - closest.r;
                  let err_g = g - closest.g;
                  let err_b = b - closest.b;
                  if (x + 1 < w) {
                      error_matrix[i + 4] += err_r * 7 / 16;
                      error_matrix[i + 5] += err_g * 7 / 16;
                      error_matrix[i + 6] += err_b * 7 / 16;
                  }
                  if (y + 1 < h) {
                      if (x > 0) {
                          error_matrix[i + 4 * w - 4] += err_r * 3 / 16;
                          error_matrix[i + 4 * w - 3] += err_g * 3 / 16;
                          error_matrix[i + 4 * w - 2] += err_b * 3 / 16;
                      }
                      error_matrix[i + 4 * w] += err_r * 5 / 16;
                      error_matrix[i + 4 * w + 1] += err_g * 5 / 16;
                      error_matrix[i + 4 * w + 2] += err_b * 5 / 16;
                      if (x + 1 < w) {
                          error_matrix[i + 4 * w + 4] += err_r * 1 / 16;
                          error_matrix[i + 4 * w + 5] += err_g * 1 / 16;
                          error_matrix[i + 4 * w + 6] += err_b * 1 / 16;
                      }
                  }
              }
          }
          const dithered_img_data = new ImageData(dithered, w, h);
          return dithered_img_data;
      }
  }

  const BabaProLogger = new BabaProLoggerFactory();

  class BabaProPalette {
    static PALETTE_LOAD_STATIC = 0;
    static PALETTE_LOAD_DYNAMIC = 1;
    static hexStrToHex(hex_str) {
      return parseInt(hex_str.slice(1), 16);
    }
    static STATIC_COLORS = [
      16777215, 12895428, 8947848, 5592405, 2236962, 0, 13880, 26112, 1799168,
      4681808, 2273612, 179713, 5366041, 9756740, 10025880, 16514907, 15063296,
      15121932, 15045888, 16740352, 16726276, 15007744, 13510969, 16728426,
      10420224, 7012352, 16741727, 10512962, 6503455, 10048269, 12275456,
      16762015, 16768972, 16754641, 13594340, 8201933, 15468780, 8519808, 3342455,
      132963, 5308671, 234, 281599, 23457, 6652879, 3586815, 33735, 54237,
      4587464, 11921646,
    ];
    static STATIC_INDEX = [
      0, 1, 2, 3, 4, 5, 39, 6, 49, 40, 7, 8, 9, 10, 41, 11, 12, 13, 14, 42, 21,
      20, 43, 44, 19, 18, 23, 15, 17, 16, 22, 24, 25, 26, 27, 45, 28, 29, 46, 31,
      30, 32, 33, 47, 34, 35, 36, 37, 38, 48,
    ];
    initalizePalette(type) {
      if (type == undefined) {
        type = BabaProPalette.PALETTE_LOAD_STATIC;
        BabaProLogger.warning(
          "BabaProPalette invoked without specifying the loading type."
        );
      }
      BabaProLogger.info(
        "BabaProPalette loading with type: " +
          (type == BabaProPalette.PALETTE_LOAD_DYNAMIC ? "DYNAMIC" : "STATIC")
      );
      if (type == BabaProPalette.PALETTE_LOAD_DYNAMIC) {
        const palette = document.getElementById("palette-buttons");
        if (!palette) {
          BabaProLogger.error(
            "Palette requested to be loaded dynamically but HTML is not loaded yet."
          );
        }
        this.colors = [];
        this.indexes = [];
        const palette_buttons = Array.from(palette.children);
        BabaProLogger.info("Dynamic loading found these DOM elements:");
        console.log(palette_buttons);
        for (const palette_button of palette_buttons) {
          const color = {
            hex: palette_button.getAttribute("title"),
            index: palette_button.getAttribute("data-id"),
          };

          this.colors.push(BabaProPalette.hexStrToHex(color.hex));
          this.indexes.push(parseInt(color.index));
        }
      } else {
        this.colors = BabaProPalette.STATIC_COLORS;
        this.indexes = BabaProPalette.STATIC_INDEX;
      }
    }
    getIndex(x) {
      if (x instanceof Array) {
        const [r, g, b] = x;
        const hex = (r << 16) | (g << 8) | b;
        return this.indexes[this.colors.indexOf(hex)] ?? -1;
      } else if (typeof x == "number") {
        return this.indexes[this.colors.indexOf(x)] ?? -1;
      } else {
        BabaProLogger.error("Argument is neither type of Array nor a number");
      }
    }
    constructor(type) {
      this.colors = undefined;
      this.indexes = undefined;
      this.initalizePalette(type);
    }
  }

  class BabaProOriginalWebSocket extends WebSocket {}

  class BabaProWS {
    constructor(babaproPalette, webSocket) {
      if (webSocket) {
        this.ws = webSocket;
        if (babaproPalette) {
          this.babaproMapCache = new BabaProMapCache(babaproPalette, this.ws);
          this.babaproMapCache.addPixelChangeListener(this);
        }
      } else {
        this.ws = undefined;
        var proxy = this;
        this.hook = class extends WebSocket {
          constructor(a, b) {
            super(a, b);
            BabaProLogger.info("BabaProWS has hooked the game WebSocket connection.");
            proxy.ws = this;
            proxy.babaproMapCache.addPixelChangeListener(proxy);
          }
        };
        if (typeof unsafeWindow !== undefined) {
          if (unsafeWindow.WebSocket != BabaProWS) {
            unsafeWindow.WebSocket = this.hook;
          }
        }
        this.babaproMapCache = new BabaProMapCache(babaproPalette, this);
      }
    }
  }

  var map_cache;
  class BabaProMapCache {
    init(babaproPalette, babaproWS) {
      var canvas_id = parseInt(location.pathname.replace("/", "").split("-")[0]);
      var url = `https://pixelplace.io/canvas/${canvas_id}.png?a=${
        Math.floor(Math.random() * 1e9) + 1e9
      }`;
      var canvas_image = new Image();
      var spare_canvas = document.createElement("canvas");
      this.before_poll = [];
      this.cache = map_cache;
      if (this.cache) return;
      spare_canvas.ctx = spare_canvas.getContext("2d");
      canvas_image.onload = () => {
        BabaProLogger.info("Map loaded");
        this.map_width = canvas_image.naturalWidth;
        this.map_height = canvas_image.naturalHeight;
        spare_canvas.width = this.map_width;
        spare_canvas.height = this.map_height;
        spare_canvas.ctx.drawImage(
          canvas_image,
          0,
          0,
          this.map_width,
          this.map_height
        );
        var data = spare_canvas.ctx.getImageData(
          0,
          0,
          this.map_width,
          this.map_height
        ).data;
        this.cache = new Int8Array(this.map_width * this.map_height);
        for (let i = 0; i < data.length; i += 4) {
          // slice is slower in custom arrays such as Int8Array
          var r = data[i];
          var g = data[i + 1];
          var b = data[i + 2];
          const i_color = babaproPalette.getIndex([r, g, b]);
          this.cache[i >> 2] = i_color;
        }
        for (let packet of this.before_poll) {
          this.cache[packet[0]] = packet[1];
        }
        this.before_poll = undefined;
      };
      canvas_image.src = url;
    }
    constructor(babaproPalette, babaproWS) {
      this.init(babaproPalette, babaproWS);
    }
    getPixel(x, y) {
      var i = y * this.map_width + x;
      return this.cache[i];
    }
    addPixelChangeListener(babaproWS) {
      babaproWS.ws.addEventListener("message", (e) => {
        var data = e.data;
        if (!data.startsWith('42["p",')) {
          return;
        }
        var packets = JSON.parse(data.replace("42", ""))[1];
        for (let packet of packets) {
          var [x, y, color] = packet;
          var i = this.map_width * y + x;
          if (this.cache) {
            this.cache[i] = color;
          } else {
            this.before_poll.push([i, color]);
          }
        }
      });
    }
  }

  class BabaProImagePicker {
    static requestImageFromFileDialog(BabaProPalette) {
      return new Promise((resolve) => {
        const input = document.createElement("input");
        input.type = "file";
        input.accept = "image/*";
        input.click();
        input.addEventListener("change", function () {
          const reader = new FileReader();
          reader.onload = function (e) {
            BabaProLogger.info("Image loaded");
            resolve(new BabaProImage(e.target.result, BabaProPalette));
          };
          if (input.files && input.files[0]) {
            reader.readAsDataURL(input.files[0]);
          }
        });
      });
    }
    static addClipboardListener(BabaProPalette, callback) {
      document.addEventListener("paste", function (paste_e) {
        var items = (paste_e.clipboardData || paste_e.originalEvent.clipboardData)
          .items;
        BabaProLogger.info(
          "Recieved data from clipboard: " + JSON.stringify(items)
        );
        var blob = null;
        for (var i = 0; i < items.length; i++) {
          if (items[i].type.indexOf("image") === 0) {
            blob = items[i].getAsFile();
          }
        }
        if (blob !== null) {
          var reader = new FileReader();
          reader.onload = function (e) {
            BabaProLogger.info("Readed image from clipboard!");
            callback(new BabaProImage(e.target.result, BabaProPalette));
          };
          reader.readAsDataURL(blob);
        }
      });
    }
  }

  function BabaProWaitForElm(selector) {
    return new Promise((resolve) => {
      if (document.querySelector(selector)) {
        return resolve(document.querySelector(selector));
      }

      const observer = new MutationObserver((mutations) => {
        if (document.querySelector(selector)) {
          resolve(document.querySelector(selector));
          observer.disconnect();
        }
      });

      observer.observe(document.body, {
        childList: true,
        subtree: true,
      });
    });
  }

  function BabaProCreateWorker(code) {
    var blob = new Blob([code], { type: "text/javascript" });

    var url = URL.createObjectURL(blob);

    var worker = new Worker(url);
    return worker;
  }

  class BabaProImage {
    constructor(x, palette) {
      this.BabaProPalette = palette;
      this.image = undefined;
      this.image_canvas = document.createElement("canvas");
      this.image_context = this.image_canvas.getContext("2d");
      if (x instanceof Image) {
        this.image = x;
      } else if (typeof x == "string") {
        this.image = new Image();
        this.image.src = x;
      }
      if (this.image == undefined) {
        BabaProLogger.error("Argument is neither type of Image nor a string");
      }
      this.image_context.mozImageSmoothingEnabled = false;
      this.image.onload = () => {
        this.image_canvas.width = this.image.width;
        this.image_canvas.height = this.image.height;
        this.image_context.drawImage(this.image, 0, 0);
        this.image_data = this.image_context.getImageData(
          0,
          0,
          this.image_canvas.width,
          this.image_canvas.height
        );
        BabaProLogger.info('Dithering loaded image!');
        this.image_data = BabaProImageConverter.floydSteinberg(this.image_data, this.image.width, this.image.height, palette);
      };
    }
    convertToTasks(sx, sy, babaproWS) {
      if (typeof sx != "number" || typeof sy != "number") {
        BabaProLogger.error(
          "Tried to convert an image to tasks yet the starting coordinates are not a number."
        );
      }
      if (!(babaproWS instanceof BabaProWS)) {
        BabaProLogger.error(
          "BabaProImage.convertToTasks requires an BabaProWS in new versions. Please update your code."
        );
      }
      var _tasks = [];
      for (let i = 0; i < this.image_data.data.length; i += 4) {
        var [r, g, b, a] = this.image_data.data.slice(i, i + 4);
        if (a == 0) {
          continue;
        }
        var x = (i / 4) % this.image_data.width;
        var y = Math.floor(i / 4 / this.image_data.width);
        var colorIndex = this.BabaProPalette.getIndex([r, g, b]);
        const c_color = babaproWS.babaproMapCache.getPixel(sx + x, sy + y);
        if (colorIndex == -1) {
          console.log([r, g, b]);
        }
        if (c_color == colorIndex || c_color == -1 || colorIndex == -1) {
          continue;
        }
        _tasks.push([sx + x, sy + y, colorIndex]);
      }
      return _tasks;
    }
  }

  class BabaProEngine {
    static convertToTask(x, y, colorIndex, packetType) {
      if (packetType == undefined) {
        packetType = 1;
      }
      return `42["p",${JSON.stringify([x, y, colorIndex, packetType])}]`;
    }
    putPixel(x, y, colorIndex) {
      this.tasks.push([x, y, colorIndex]);
    }
    putPixelWithPriority(x, y, colorIndex) {
      this.tasks.unshift([x, y, colorIndex]);
    }
    constructor(BabaProWS, timeout) {
      if (!BabaProWS || !timeout) {
        return;
      }
      this.tasks = [];
      this.BabaProWS = BabaProWS;
      this.intervalID = setInterval(() => {
        const task = this.tasks.shift();
        if (!task) {
          return;
        }
        if (this.BabaProWS.babaproMapCache.getPixel(task[0], task[1]) == task[2]) {
          return;
        }
        this.BabaProWS.ws.send(BabaProEngine.convertToTask(...task));
      }, timeout);
    }
  }

  class BabaProEngineMultiBot extends BabaProEngine {
    static getAccountDetailsFromCookie(cookie) {
      const dict = cookie
        .split("; ")
        .map((a) => a.split("="))
        .reduce(function (b, a) {
          if (!["authKey", "authToken", "authId"].includes(a[0])) return b;
          b[a[0]] = a[1];
          return b;
        }, {});
      return [dict.authId, dict.authToken, dict.authKey];
    }
    addAccountFromCookies(authId, authToken, authKey) {
      if (!authId || !authToken || !authKey) {
        BabaProLogger.warning(
          "Auth informations are not defined. (Maybe not logged in?)"
        );
        return;
      }
      const boardId = parseInt(location.pathname.replace("/", "").split("-")[0]);
      const socket = new BabaProOriginalWebSocket(
        "wss://pixelplace.io/socket.io/?EIO=3&transport=websocket"
      );
      socket.headless = true;
      socket.onmessage = ({ data }) => {
        const [code, msg] = data.split(/(?<=^\d+)(?=[^\d])/);
        if (code == "40") {
          socket.send(
            "42" +
              JSON.stringify(["init", { authKey, authToken, authId, boardId }])
          );
        }

        const message = JSON.parse(msg || "[]");
        if (message.pingInterval)
          socket.ping = setInterval(() => socket.send("2"), message.pingInterval);

        if (!message.length) return arguments;
        const [event, json] = message;
        if (event == "throw.error") {
          socket.close();
          BabaProLogger.error(json);
        }
      };
      socket.onclose = () => {
        BabaProLogger.info("User Disconnected");
      };
      const babaproWS = new BabaProWS(undefined, socket);
      this.sockets.push(babaproWS);
    }
    addAccountFromBabaProWS(babaproWS) {
      this.sockets.push(babaproWS);
    }
    constructor(timeout, babaproPalette) {
      super();
      this.tasks = [];
      this.sockets = [];
      this.counter = 0;
      function interval() {
        if (this.sockets.length == 0) {
          setTimeout(interval, 100);
          return;
        }
        const task = this.tasks.shift();
        if (!task) {
          setTimeout(interval, timeout / this.sockets.length);
          return;
        }
        console.log(this);
        this.counter = (this.counter + 1) % this.sockets.length;
        this.sockets[this.counter]?.ws?.send(BabaProEngine.convertToTask(...task));
        setTimeout(this.interval, timeout / this.sockets.length);
      }
      interval = interval.bind(this);
      interval();
      this.interval = interval;
    }
  }
  class BabaProProtect {
    constructor(core) {
      BabaProLogger.info("BabaProProtect has been opened.");
      this.core = core;
      this.nimage = undefined;
      this.coordinates = undefined;
      this.working = false;
      this.core.babaproWS.ws.addEventListener(
        "message",
        function (e) {
          if (!this.working) return;
          if (!this.nimage) return;
          if (!this.coordinates) return;
          var data = e.data;
          if (!data.startsWith('42["p",')) {
            return;
          }
          var packets = JSON.parse(data.replace("42", ""))[1];
          for (let packet of packets) {
            var [x, y, color] = packet;
            var image_width = this.nimage.image.width;
            var image_height = this.nimage.image.height;
            var image_x = this.coordinates[0];
            var image_y = this.coordinates[1];
            var image_xmax = image_width + image_x;
            var image_ymax = image_height + image_y;
            if (!this.nimage) {
              continue;
            }
            if (
              x < image_x ||
              x >= image_xmax ||
              y < image_y ||
              y >= image_ymax
            ) {
              continue;
            }
            var img_data_index = 4 * (x - image_x + image_width * (y - image_y));
            var [r, g, b, a] = this.nimage.image_data.data.slice(
              img_data_index,
              img_data_index + 4
            );
            if (a == 0) continue;
            var image_color_i = this.core.palette.getIndex([r, g, b]);
            if (image_color_i == undefined) {
              BabaProLogger.error(
                JSON.stringify([[r, g, b], image_color_i, img_data_index])
              );
            }
            if (image_color_i != color) {
              this.core.engine.putPixelWithPriority(x, y, image_color_i);
            }
          }
        }.bind(this)
      );
    }
    start() {
      this.working = true;
    }
    stop() {
      this.working = false;
    }
    load(nimage, coordinates) {
      this.nimage = nimage;
      this.coordinates = coordinates;
    }
  }

  class BabaProCore {
    async testAccountValidation() {
      const req = await fetch(
        "https://pixelplace.io/api/get-painting.php?id=7&connected=1"
      );
      const json = await req.json();
      if (json.user.name == "Guest") {
        BabaProLogger.warning("User is not logged in!");
      } else {
        BabaProLogger.info("Logged in as " + json.user.name);
      }
    }
    constructor(options) {
      this.testAccountValidation();
      this.palette = new BabaProPalette(BabaProPalette.PALETTE_LOAD_STATIC);
      //        this.accountManager = new BabaProAccountManager();
      this.babaproWS = new BabaProWS(this.palette); //, this.accountManager);
      if (options.multibot) {
        this.engine = new BabaProEngineMultiBot(options.timeout);
        localStorage.babaproAccounts = localStorage.babaproAccounts || "[]";
        const babaproAccounts = JSON.parse(localStorage.babaproAccounts);
        unsafeWindow.addThisAccount = function () {
          const session_account = BabaProEngineMultiBot.getAccountDetailsFromCookie(
            document.cookie
          ).join("_AND_");
          if (session_account[0] && !babaproAccounts.includes(session_account)) {
            babaproAccounts.push(session_account);
          }
          localStorage.babaproAccounts = JSON.stringify(babaproAccounts);
        };
        for (let account of babaproAccounts) {
          const [authId, authToken, authKey] = account.split("_AND_");
          if (!authId || !authToken || !authKey) {
            console.error(account);
            BabaProLogger.error("Local account is corrupted");
          }
          this.engine.addAccountFromCookies(authId, authToken, authKey);
        }
      } else {
        this.engine = new BabaProEngine(this.babaproWS, options.timeout);
      }
      this.picker = BabaProImagePicker;
      this.logger = BabaProLogger;
    }
  }