☰

IdlePixel+

Idle-Pixel plugin framework

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

此脚本不应直接安装。它是供其他脚本使用的外部库，要使用该库请加入元指令 // @require https://update.cn-greasyfork.org/scripts/441206/1068464/IdlePixel%2B.js 

  1. // ==UserScript==
  2. // @name         IdlePixel+
  3. // @namespace    com.anwinity.idlepixel
  4. // @version      0.2.1
  5. // @description  Idle-Pixel plugin framework
  6. // @author       Anwinity
  7. // @match        *://idle-pixel.com/login/play*
  8. // @grant        none
  9. // ==/UserScript==
  10.  
  11. (function() {
  12.     'use strict';
  13.  
  14.     const CONFIG_TYPES_LABEL = ["label"];
  15.     const CONFIG_TYPES_BOOLEAN = ["boolean", "bool", "checkbox"];
  16.     const CONFIG_TYPES_INTEGER = ["integer", "int"];
  17.     const CONFIG_TYPES_FLOAT = ["number", "num", "float"];
  18.     const CONFIG_TYPES_STRING = ["string", "text"];
  19.     const CONFIG_TYPES_SELECT = ["select"];
  20.     const CONFIG_TYPES_COLOR = ["color"];
  21.  
  22.     const INFO = {
  23.         ores: {
  24.             stone: {
  25.                 id: "stone",
  26.                 smeltable: false,
  27.                 oil: 0,
  28.                 bar: null,
  29.                 sellsFor: 1,
  30.                 miningXP: 0.1
  31.             },
  32.             copper: {
  33.                 id: "copper",
  34.                 smeltable: true,
  35.                 oil: 1,
  36.                 bar: "bronze_bar",
  37.                 sellsFor: 2,
  38.                 miningXP: 1
  39.             },
  40.             iron: {
  41.                 id: "iron",
  42.                 smeltable: true,
  43.                 oil: 5,
  44.                 bar: "iron_bar",
  45.                 sellsFor: 3,
  46.                 miningXP: 5
  47.             },
  48.             silver: {
  49.                 id: "silver",
  50.                 smeltable: true,
  51.                 oil: 20,
  52.                 bar: "silver_bar",
  53.                 sellsFor: 5,
  54.                 miningXP: 10
  55.             },
  56.             gold: {
  57.                 id: "gold",
  58.                 smeltable: true,
  59.                 oil: 100,
  60.                 bar: "gold_bar",
  61.                 sellsFor: 10,
  62.                 miningXP: 20
  63.             },
  64.             promethium: {
  65.                 id: "promethium",
  66.                 smeltable: false,
  67.                 oil: 0,
  68.                 bar: "promethium_bar",
  69.                 sellsFor: 90,
  70.                 miningXP: 100
  71.             }
  72.         },
  73.         bars: {
  74.             bronze_bar: {
  75.                 id: "bronze_bar",
  76.                 sellsFor: 3,
  77.                 craftingXP: 5
  78.             },
  79.             iron_bar: {
  80.                 id: "iron_bar",
  81.                 sellsFor: 5,
  82.                 craftingXP: 25
  83.             },
  84.             silver_bar: {
  85.                 id: "silver_bar",
  86.                 sellsFor: 10,
  87.                 craftingXP: 50
  88.             },
  89.             gold_bar: {
  90.                 id: "gold_bar",
  91.                 sellsFor: 50,
  92.                 craftingXP: 100
  93.             },
  94.             promethium_bar: {
  95.                 id: "promethium_bar",
  96.                 sellsFor: 1000,
  97.                 craftingXP: 500
  98.             }
  99.         },
  100.         seeds: {
  101.             dotted_green_leaf_seeds: {
  102.                 id: "dotted_green_leaf_seeds",
  103.                 level: 1,
  104.                 stopsDying: 15,
  105.                 time: 15,
  106.                 bonemealCost: 0
  107.             },
  108.             green_leaf_seeds: {
  109.                 id: "green_leaf_seeds",
  110.                 level: 15,
  111.                 stopsDying: 30,
  112.                 time: 30,
  113.                 bonemealCost: 0
  114.             },
  115.             lime_leaf_seeds: {
  116.                 id: "lime_leaf_seeds",
  117.                 level: 30,
  118.                 stopsDying: 40,
  119.                 time: 1*60,
  120.                 bonemealCost: 1
  121.             },
  122.             gold_leaf_seeds: {
  123.                 id: "gold_leaf_seeds",
  124.                 level: 50,
  125.                 stopsDying: 60,
  126.                 time: 2*60,
  127.                 bonemealCost: 10
  128.             },
  129.             crystal_leaf_seeds: {
  130.                 id: "crystal_leaf_seeds",
  131.                 level: 70,
  132.                 stopsDying: 80,
  133.                 time: 5*60,
  134.                 bonemealCost: 25
  135.             },
  136.             red_mushroom_seeds: {
  137.                 id: "red_mushroom_seeds",
  138.                 level: 1,
  139.                 stopsDying: 5,
  140.                 time: 5,
  141.                 bonemealCost: 0
  142.             },
  143.             tree_seeds: {
  144.                 id: "tree_seeds",
  145.                 level: 10,
  146.                 stopsDying: 25,
  147.                 time: 5*60,
  148.                 bonemealCost: 10
  149.             },
  150.             oak_tree_seeds: {
  151.                 id: "oak_tree_seeds",
  152.                 level: 25,
  153.                 stopsDying: 40,
  154.                 time: 8*60,
  155.                 bonemealCost: 25
  156.             },
  157.             willow_tree_seeds: {
  158.                 id: "willow_tree_seeds",
  159.                 level: 37,
  160.                 stopsDying: 55,
  161.                 time: 12*60,
  162.                 bonemealCost: 50
  163.             },
  164.             maple_tree_seeds: {
  165.                 id: "maple_tree_seeds",
  166.                 level: 50,
  167.                 stopsDying: 65,
  168.                 time: 15*60,
  169.                 bonemealCost: 120
  170.             }
  171.         },
  172.         combatZones: {
  173.             field: {
  174.                 id: "field",
  175.                 energyCost: 50,
  176.                 fightPointCost: 300
  177.             },
  178.             forest: {
  179.                 id: "forest",
  180.                 energyCost: 200,
  181.                 fightPointCost: 600
  182.             },
  183.             cave: {
  184.                 id: "cave",
  185.                 energyCost: 500,
  186.                 fightPointCost: 900
  187.             },
  188.             volcano: {
  189.                 id: "volcano",
  190.                 energyCost: 2000,
  191.                 fightPointCost: 1500
  192.             }
  193.         },
  194.         spellManaCost: {
  195.             heal: 2
  196.         }
  197.     };
  198.  
  199.     if(window.IdlePixelPlus) {
  200.         // already loaded
  201.         return;
  202.     }
  203.  
  204.     class IdlePixelPlusPlugin {
  205.  
  206.         constructor(id, opts) {
  207.             if(typeof id !== "string") {
  208.                 throw new TypeError("IdlePixelPlusPlugin constructor takes the following arguments: (id:string, opts?:object)");
  209.             }
  210.             this.id = id;
  211.             this.opts = opts || {};
  212.             this.config = null;
  213.         }
  214.  
  215.         getConfig(name) {
  216.             if(!this.config) {
  217.                 IdlePixelPlus.loadPluginConfigs(this.id);
  218.             }
  219.             if(this.config) {
  220.                 return this.config[name];
  221.             }
  222.         }
  223.  
  224.         /*
  225.         onConfigsChanged() { }
  226.         onLogin() { }
  227.         onMessageReceived(data) { }
  228.         onVariableSet(key, valueBefore, valueAfter) { }
  229.         onChat(data) { }
  230.         onPanelChanged(panelBefore, panelAfter) { }
  231.         onCombatStart() { }
  232.         onCombatEnd() { }
  233.         */
  234.  
  235.     }
  236.  
  237.     const internal = {
  238.         init() {
  239.             const self = this;
  240.  
  241.             // hook into websocket messages
  242.             const original_onmessage = window.websocket.websocket.onmessage;
  243.             $(function() {
  244.                 window.websocket.websocket.onmessage = function(event) {
  245.                     original_onmessage.apply(window.websocket.websocket, arguments);
  246.                     self.onMessageReceived(event.data);
  247.                 }
  248.             });
  249.  
  250.             /*
  251.             const original_open_websocket = window.open_websocket;
  252.             window.open_websocket = function() {
  253.                 original_open_websocket.apply(this, arguments);
  254.                 const original_onmessage = window.websocket.websocket.onmessage;
  255.                 window.websocket.websocket.onmessage = function(event) {
  256.                     original_onmessage.apply(window.websocket.websocket, arguments);
  257.                     self.onMessageReceived(event.data);
  258.                 }
  259.             }
  260.             */
  261.  
  262.             // hook into Items.set, which is where var_ values are set
  263.             const original_items_set = Items.set;
  264.             Items.set = function(key, value) {
  265.                 let valueBefore = window["var_"+key];
  266.                 original_items_set.apply(this, arguments);
  267.                 let valueAfter = window["var_"+key];
  268.                 self.onVariableSet(key, valueBefore, valueAfter);
  269.             }
  270.  
  271.             // hook into switch_panels, which is called when the main panel is changed. This is also used for custom panels.
  272.             const original_switch_panels = window.switch_panels;
  273.             window.switch_panels = function(id) {
  274.                 let panelBefore = Globals.currentPanel;
  275.                 if(panelBefore && panelBefore.startsWith("panel-")) {
  276.                     panelBefore = panelBefore.substring("panel-".length);
  277.                 }
  278.                 self.hideCustomPanels();
  279.                 original_switch_panels.apply(this, arguments);
  280.                 let panelAfter = Globals.currentPanel;
  281.                 if(panelAfter && panelAfter.startsWith("panel-")) {
  282.                     panelAfter = panelAfter.substring("panel-".length);
  283.                 }
  284.                 self.onPanelChanged(panelBefore, panelAfter);
  285.             }
  286.  
  287.             // create plugin menu item and panel
  288.             const lastMenuItem = $("#menu-bar-buttons > .hover-menu-bar-item").last();
  289.             lastMenuItem.after(`
  290.             <div onclick="IdlePixelPlus.setPanel('idlepixelplus')" class="hover hover-menu-bar-item">
  291.                 <img id="menu-bar-idlepixelplus-icon" src="https://anwinity.com/idlepixelplus/plugins.png"> PLUGINS
  292.             </div>
  293.             `);
  294.             self.addPanel("idlepixelplus", "IdlePixel+ Plugins", function() {
  295.                 let content = `
  296.                 <style>
  297.                     .idlepixelplus-plugin-box {
  298.                         display: block;
  299.                         position: relative;
  300.                         padding: 0.25em;
  301.                         color: white;
  302.                         background-color: rgb(107, 107, 107);
  303.                         border: 1px solid black;
  304.                         border-radius: 6px;
  305.                         margin-bottom: 0.5em;
  306.                     }
  307.                     .idlepixelplus-plugin-box .idlepixelplus-plugin-settings-button {
  308.                         position: absolute;
  309.                         right: 2px;
  310.                         top: 2px;
  311.                         cursor: pointer;
  312.                     }
  313.                     .idlepixelplus-plugin-box .idlepixelplus-plugin-config-section {
  314.                         display: grid;
  315.                         grid-template-columns: minmax(100px, min-content) 1fr;
  316.                         row-gap: 0.5em;
  317.                         column-gap: 0.5em;
  318.                         white-space: nowrap;
  319.                     }
  320.                 </style>
  321.                 `;
  322.                 self.forEachPlugin(plugin => {
  323.                     let id = plugin.id;
  324.                     let name = "An IdlePixel+ Plugin!";
  325.                     let description = "";
  326.                     let author = "unknown";
  327.                     if(plugin.opts.about) {
  328.                         let about = plugin.opts.about;
  329.                         name = about.name || name;
  330.                         description = about.description || description;
  331.                         author = about.author || author;
  332.                     }
  333.                     content += `
  334.                     <div id="idlepixelplus-plugin-box-${id}" class="idlepixelplus-plugin-box">
  335.                         <strong><u>${name||id}</u></strong> (by ${author})<br />
  336.                         <span>${description}</span><br />
  337.                         <div class="idlepixelplus-plugin-config-section" style="display: none">
  338.                             <hr style="grid-column: span 2">
  339.                     `;
  340.                     if(plugin.opts.config && Array.isArray(plugin.opts.config)) {
  341.                         plugin.opts.config.forEach(cfg => {
  342.                             if(CONFIG_TYPES_LABEL.includes(cfg.type)) {
  343.                                 content += `<h5 style="grid-column: span 2; margin-bottom: 0; font-weight: 600">${cfg.label}</h5>`;
  344.                             }
  345.                             else if(CONFIG_TYPES_BOOLEAN.includes(cfg.type)) {
  346.                                 content += `
  347.                                     <div>
  348.                                         <label for="idlepixelplus-config-${plugin.id}-${cfg.id}">${cfg.label || cfg.id}</label>
  349.                                     </div>
  350.                                     <div>
  351.                                         <input id="idlepixelplus-config-${plugin.id}-${cfg.id}" type="checkbox" onchange="IdlePixelPlus.setPluginConfigUIDirty('${id}', true)" />
  352.                                     </div>
  353.                                     `;
  354.                             }
  355.                             else if(CONFIG_TYPES_INTEGER.includes(cfg.type)) {
  356.                                 content += `
  357.                                     <div>
  358.                                         <label for="idlepixelplus-config-${plugin.id}-${cfg.id}">${cfg.label || cfg.id}</label>
  359.                                     </div>
  360.                                     <div>
  361.                                         <input id="idlepixelplus-config-${plugin.id}-${cfg.id}" type="number" step="1" min="${cfg.min || ''}" max="${cfg.max || ''}" onchange="IdlePixelPlus.setPluginConfigUIDirty('${id}', true)" />
  362.                                     </div>
  363.                                     `;
  364.                             }
  365.                             else if(CONFIG_TYPES_FLOAT.includes(cfg.type)) {
  366.                                 content += `
  367.                                     <div>
  368.                                         <label for="idlepixelplus-config-${plugin.id}-${cfg.id}">${cfg.label || cfg.id}</label>
  369.                                     </div>
  370.                                     <div>
  371.                                         <input id="idlepixelplus-config-${plugin.id}-${cfg.id}" type="number" step="${cfg.step || ''}" min="${cfg.min || ''}" max="${cfg.max || ''}" onchange="IdlePixelPlus.setPluginConfigUIDirty('${id}', true)" />
  372.                                     </div>
  373.                                     `;
  374.                             }
  375.                             else if(CONFIG_TYPES_STRING.includes(cfg.type)) {
  376.                                 content += `
  377.                                     <div>
  378.                                         <label for="idlepixelplus-config-${plugin.id}-${cfg.id}">${cfg.label || cfg.id}</label>
  379.                                     </div>
  380.                                     <div>
  381.                                         <input id="idlepixelplus-config-${plugin.id}-${cfg.id}" type="text" maxlength="${cfg.max || ''}" onchange="IdlePixelPlus.setPluginConfigUIDirty('${id}', true)" />
  382.                                     </div>
  383.                                     `;
  384.                             }
  385.                             else if(CONFIG_TYPES_COLOR.includes(cfg.type)) {
  386.                                 content += `
  387.                                     <div>
  388.                                         <label for="idlepixelplus-config-${plugin.id}-${cfg.id}">${cfg.label || cfg.id}</label>
  389.                                     </div>
  390.                                     <div>
  391.                                         <input id="idlepixelplus-config-${plugin.id}-${cfg.id}" type="color" onchange="IdlePixelPlus.setPluginConfigUIDirty('${id}', true)" />
  392.                                     </div>
  393.                                     `;
  394.                             }
  395.                             else if(CONFIG_TYPES_SELECT.includes(cfg.type)) {
  396.                                 content += `
  397.                                     <div>
  398.                                         <label for="idlepixelplus-config-${plugin.id}-${cfg.id}">${cfg.label || cfg.id}</label>
  399.                                     </div>
  400.                                     <div>
  401.                                         <select id="idlepixelplus-config-${plugin.id}-${cfg.id}" onchange="IdlePixelPlus.setPluginConfigUIDirty('${id}', true)">
  402.                                     `;
  403.                                 if(cfg.options && Array.isArray(cfg.options)) {
  404.                                     cfg.options.forEach(option => {
  405.                                         if(typeof option === "string") {
  406.                                             content += `<option value="${option}">${option}</option>`;
  407.                                         }
  408.                                         else {
  409.                                             content += `<option value="${option.value}">${option.label || option.value}</option>`;
  410.                                         }
  411.                                         
  412.                                     });
  413.                                 }
  414.                                 content += `
  415.                                         </select>
  416.                                     </div>
  417.                                     `;
  418.                             }
  419.                         });
  420.                         content += `
  421.                         <div style="grid-column: span 2">
  422.                             <button id="idlepixelplus-configbutton-${plugin.id}-reload" onclick="IdlePixelPlus.loadPluginConfigs('${id}')">Reload</button>
  423.                             <button id="idlepixelplus-configbutton-${plugin.id}-apply" onclick="IdlePixelPlus.savePluginConfigs('${id}')">Apply</button>
  424.                         </div>
  425.                         `;
  426.                     }
  427.                     content += "</div>";
  428.                     if(plugin.opts.config) {
  429.                         content += `
  430.                         <div class="idlepixelplus-plugin-settings-button">
  431.                             <button onclick="$('#idlepixelplus-plugin-box-${id} .idlepixelplus-plugin-config-section').toggle()">Settings</button>
  432.                         </div>`;
  433.                     }
  434.                     content += "</div>";
  435.                 });
  436.  
  437.                 return content;
  438.             });
  439.  
  440.             console.log(`IdlePixelPlus (v${self.version}) initialized.`);
  441.         }
  442.     };
  443.  
  444.     class IdlePixelPlus {
  445.  
  446.         constructor() {
  447.             this.version = GM_info.script.version;
  448.             this.plugins = {};
  449.             this.panels = {};
  450.             this.debug = false;
  451.             this.info = INFO;
  452.         }
  453.  
  454.         getVar(name, type) {
  455.             let s = window[`var_${name}`];
  456.             if(type) {
  457.                 switch(type) {
  458.                     case "int":
  459.                     case "integer":
  460.                         return parseInt(s);
  461.                     case "number":
  462.                     case "float":
  463.                         return parseFloat(s);
  464.                     case "boolean":
  465.                     case "bool":
  466.                         if(s=="true") return true;
  467.                         if(s=="false") return false;
  468.                         return undefined;
  469.                 }
  470.             }
  471.             return s;
  472.         }
  473.  
  474.         getVarOrDefault(name, defaultValue, type) {
  475.             let s = window[`var_${name}`];
  476.             if(s==null || typeof s === "undefined") {
  477.                 return defaultValue;
  478.             }
  479.             if(type) {
  480.                 let value;
  481.                 switch(type) {
  482.                     case "int":
  483.                     case "integer":
  484.                         value = parseInt(s);
  485.                         return isNaN(value) ? defaultValue : value;
  486.                     case "number":
  487.                     case "float":
  488.                         value = parseFloat(s);
  489.                         return isNaN(value) ? defaultValue : value;
  490.                     case "boolean":
  491.                     case "bool":
  492.                         if(s=="true") return true;
  493.                         if(s=="false") return false;
  494.                         return defaultValue;
  495.                 }
  496.             }
  497.             return s;
  498.         }
  499.  
  500.         setPluginConfigUIDirty(id, dirty) {
  501.             if(typeof id !== "string" || typeof dirty !== "boolean") {
  502.                 throw new TypeError("IdlePixelPlus.setPluginConfigUIDirty takes the following arguments: (id:string, dirty:boolean)");
  503.             }
  504.             const plugin = this.plugins[id];
  505.             const button = $(`#idlepixelplus-configbutton-${plugin.id}-apply`);
  506.             if(button) {
  507.                 button.prop("disabled", !(dirty));
  508.             }
  509.         }
  510.  
  511.         loadPluginConfigs(id) {
  512.             if(typeof id !== "string") {
  513.                 throw new TypeError("IdlePixelPlus.reloadPluginConfigs takes the following arguments: (id:string)");
  514.             }
  515.             const plugin = this.plugins[id];
  516.             const config = {};
  517.             let stored;
  518.             try {
  519.                 stored = JSON.parse(localStorage.getItem(`idlepixelplus.${id}.config`) || "{}");
  520.             }
  521.             catch(err) {
  522.                 console.error(`Failed to load configs for plugin with id "${id} - will use defaults instead."`);
  523.                 stored = {};
  524.             }
  525.             if(plugin.opts.config && Array.isArray(plugin.opts.config)) {
  526.                 plugin.opts.config.forEach(cfg => {
  527.                     const el = $(`#idlepixelplus-config-${plugin.id}-${cfg.id}`);
  528.                     let value = stored[cfg.id];
  529.                     if(value==null || typeof value === "undefined") {
  530.                         value = cfg.default;
  531.                     }
  532.                     config[cfg.id] = value;
  533.  
  534.                     if(el) {
  535.                         if(CONFIG_TYPES_BOOLEAN.includes(cfg.type) && typeof value === "boolean") {
  536.                             el.prop("checked", value);
  537.                         }
  538.                         else if(CONFIG_TYPES_INTEGER.includes(cfg.type) && typeof value === "number") {
  539.                             el.val(value);
  540.                         }
  541.                         else if(CONFIG_TYPES_FLOAT.includes(cfg.type) && typeof value === "number") {
  542.                             el.val(value);
  543.                         }
  544.                         else if(CONFIG_TYPES_STRING.includes(cfg.type) && typeof value === "string") {
  545.                             el.val(value);
  546.                         }
  547.                         else if(CONFIG_TYPES_SELECT.includes(cfg.type) && typeof value === "string") {
  548.                             el.val(value);
  549.                         }
  550.                         else if(CONFIG_TYPES_COLOR.includes(cfg.type) && typeof value === "string") {
  551.                             el.val(value);
  552.                         }
  553.                     }
  554.                 });
  555.             }
  556.             plugin.config = config;
  557.             this.setPluginConfigUIDirty(id, false);
  558.             if(typeof plugin.onConfigsChanged === "function") {
  559.                 plugin.onConfigsChanged();
  560.             }
  561.         }
  562.  
  563.         savePluginConfigs(id) {
  564.             if(typeof id !== "string") {
  565.                 throw new TypeError("IdlePixelPlus.savePluginConfigs takes the following arguments: (id:string)");
  566.             }
  567.             const plugin = this.plugins[id];
  568.             const config = {};
  569.             if(plugin.opts.config && Array.isArray(plugin.opts.config)) {
  570.                 plugin.opts.config.forEach(cfg => {
  571.                     const el = $(`#idlepixelplus-config-${plugin.id}-${cfg.id}`);
  572.                     let value;
  573.                     if(CONFIG_TYPES_BOOLEAN.includes(cfg.type)) {
  574.                         config[cfg.id] = el.is(":checked");
  575.                     }
  576.                     else if(CONFIG_TYPES_INTEGER.includes(cfg.type)) {
  577.                         config[cfg.id] = parseInt(el.val());
  578.                     }
  579.                     else if(CONFIG_TYPES_FLOAT.includes(cfg.type)) {
  580.                         config[cfg.id] = parseFloat(el.val());
  581.                     }
  582.                     else if(CONFIG_TYPES_STRING.includes(cfg.type)) {
  583.                         config[cfg.id] = el.val();
  584.                     }
  585.                     else if(CONFIG_TYPES_SELECT.includes(cfg.type)) {
  586.                         config[cfg.id] = el.val();
  587.                     }
  588.                     else if(CONFIG_TYPES_COLOR.includes(cfg.type)) {
  589.                         config[cfg.id] = el.val();
  590.                     }
  591.                 });
  592.             }
  593.             plugin.config = config;
  594.             localStorage.setItem(`idlepixelplus.${id}.config`, JSON.stringify(config));
  595.             this.setPluginConfigUIDirty(id, false);
  596.             if(typeof plugin.onConfigsChanged === "function") {
  597.                 plugin.onConfigsChanged();
  598.             }
  599.         }
  600.  
  601.         addPanel(id, title, content) {
  602.             if(typeof id !== "string" || typeof title !== "string" || (typeof content !== "string" && typeof content !== "function") ) {
  603.                 throw new TypeError("IdlePixelPlus.addPanel takes the following arguments: (id:string, title:string, content:string|function)");
  604.             }
  605.             const panels = $("#panels");
  606.             panels.append(`
  607.             <div id="panel-${id}" style="display: none">
  608.                 <h1>${title}</h1>
  609.                 <hr>
  610.                 <div class="idlepixelplus-panel-content"></div>
  611.             </div>
  612.             `);
  613.             this.panels[id] = {
  614.                 id: id,
  615.                 title: title,
  616.                 content: content
  617.             };
  618.             this.refreshPanel(id);
  619.         }
  620.  
  621.         refreshPanel(id) {
  622.             if(typeof id !== "string") {
  623.                 throw new TypeError("IdlePixelPlus.refreshPanel takes the following arguments: (id:string)");
  624.             }
  625.             const panel = this.panels[id];
  626.             if(!panel) {
  627.                 throw new TypeError(`Error rendering panel with id="${id}" - panel has not be added.`);
  628.             }
  629.             let content = panel.content;
  630.             if(!["string", "function"].includes(typeof content)) {
  631.                 throw new TypeError(`Error rendering panel with id="${id}" - panel.content must be a string or a function returning a string.`);
  632.             }
  633.             if(typeof content === "function") {
  634.                 content = content();
  635.                 if(typeof content !== "string") {
  636.                     throw new TypeError(`Error rendering panel with id="${id}" - panel.content must be a string or a function returning a string.`);
  637.                 }
  638.             }
  639.             const panelContent = $(`#panel-${id} .idlepixelplus-panel-content`);
  640.             panelContent.html(content);
  641.             if(id === "idlepixelplus") {
  642.                 this.forEachPlugin(plugin => {
  643.                     this.loadPluginConfigs(plugin.id);
  644.                 });
  645.             }
  646.         }
  647.  
  648.         registerPlugin(plugin) {
  649.             if(!(plugin instanceof IdlePixelPlusPlugin)) {
  650.                 throw new TypeError("IdlePixelPlus.registerPlugin takes the following arguments: (plugin:IdlePixelPlusPlugin)");
  651.             }
  652.             if(plugin.id in this.plugins) {
  653.                 throw new Error(`IdlePixelPlusPlugin with id "${plugin.id}" is already registered. Make sure your plugin id is unique!`);
  654.             }
  655.  
  656.             // TODO: easy config system
  657.             // TODO: custom panels
  658.  
  659.             this.plugins[plugin.id] = plugin;
  660.             this.loadPluginConfigs(plugin.id);
  661.             console.log(`IdlePixelPlus registered plugin "${plugin.id}"`);
  662.         }
  663.  
  664.         forEachPlugin(f) {
  665.             if(typeof f !== "function") {
  666.                 throw new TypeError("IdlePixelPlus.forEachPlugin takes the following arguments: (f:function)");
  667.             }
  668.             Object.values(this.plugins).forEach(plugin => {
  669.                 try {
  670.                     f(plugin);
  671.                 }
  672.                 catch(err) {
  673.                     console.error(`Error occurred while executing function for plugin "${plugin.id}."`);
  674.                     console.error(err);
  675.                 }
  676.             });
  677.         }
  678.  
  679.         setPanel(panel) {
  680.             if(typeof panel !== "string") {
  681.                 throw new TypeError("IdlePixelPlus.setPanel takes the following arguments: (panel:string)");
  682.             }
  683.             window.switch_panels(`panel-${panel}`);
  684.         }
  685.  
  686.         sendMessage(message) {
  687.             if(typeof message !== "string") {
  688.                 throw new TypeError("IdlePixelPlus.sendMessage takes the following arguments: (message:string)");
  689.             }
  690.             if(window.websocket && window.websocket.websocket && window.websocket.websocket.readyState==1) {
  691.                 window.websocket.websocket.send(message);
  692.             }
  693.         }
  694.  
  695.         showToast(title, content) {
  696.             show_toast(title, content);
  697.         }
  698.  
  699.         hideCustomPanels() {
  700.             Object.values(this.panels).forEach((panel) => {
  701.                 const el = $(`#panel-${panel.id}`);
  702.                 if(el) {
  703.                     el.css("display", "none");
  704.                 }
  705.             });
  706.         }
  707.  
  708.         onMessageReceived(data) {
  709.             if(this.debug) {
  710.                 console.log(`IP+ onMessageReceived: ${data}`);
  711.             }
  712.             if(data) {
  713.                 this.forEachPlugin((plugin) => {
  714.                     if(typeof plugin.onMessageReceived === "function") {
  715.                         plugin.onMessageReceived(data);
  716.                     }
  717.                 });
  718.                 if(data.startsWith("VALID_LOGIN")) {
  719.                     this.onLogin();
  720.                 }
  721.                 else if(data.startsWith("CHAT=")) {
  722.                     const split = data.substring("CHAT=".length).split("~");
  723.                     const chatData = {
  724.                         username: split[0],
  725.                         tag: split[1],
  726.                         sigil: split[2],
  727.                         level: parseInt(split[3]),
  728.                         message: split[4]
  729.                     };
  730.                     this.onChat(chatData);
  731.                     // CHAT=anwinity~none~none~1565~test
  732.                 }
  733.             }
  734.         }
  735.  
  736.         onCombatStart() {
  737.             if(this.debug) {
  738.                 console.log(`IP+ onCombatStart`);
  739.             }
  740.             this.forEachPlugin((plugin) => {
  741.                 if(typeof plugin.onCombatStart === "function") {
  742.                     plugin.onCombatStart();
  743.                 }
  744.             });
  745.         }
  746.  
  747.         onCombatEnd() {
  748.             if(this.debug) {
  749.                 console.log(`IP+ onCombatEnd`);
  750.             }
  751.             this.forEachPlugin((plugin) => {
  752.                 if(typeof plugin.onCombatEnd === "function") {
  753.                     plugin.onCombatEnd();
  754.                 }
  755.             });
  756.         }
  757.  
  758.         onLogin() {
  759.             if(this.debug) {
  760.                 console.log(`IP+ onLogin`);
  761.             }
  762.             console.log("idlePixelPlus login detected");
  763.             this.forEachPlugin((plugin) => {
  764.                 if(typeof plugin.onLogin === "function") {
  765.                     plugin.onLogin();
  766.                 }
  767.             });
  768.         }
  769.  
  770.         onVariableSet(key, valueBefore, valueAfter) {
  771.             if(this.debug) {
  772.                 console.log(`IP+ onVariableSet "${key}": "${valueBefore}" -> "${valueAfter}"`);
  773.             }
  774.             this.forEachPlugin((plugin) => {
  775.                 if(typeof plugin.onVariableSet === "function") {
  776.                     plugin.onVariableSet(key, valueBefore, valueAfter);
  777.                 }
  778.             });
  779.             if(key == "monster_name") {
  780.                 const combatBefore = !!(valueBefore && valueBefore!="none");
  781.                 const combatAfter = !!(valueAfter && valueAfter!="none");
  782.                 if(!combatBefore && combatAfter) {
  783.                     this.onCombatStart();
  784.                 }
  785.                 else if(combatBefore && !combatAfter) {
  786.                     this.onCombatEnd();
  787.                 }
  788.             }
  789.         }
  790.  
  791.         onChat(data) {
  792.             if(this.debug) {
  793.                 console.log(`IP+ onChat`, data);
  794.             }
  795.             this.forEachPlugin((plugin) => {
  796.                 if(typeof plugin.onChat === "function") {
  797.                     plugin.onChat(data);
  798.                 }
  799.             });
  800.         }
  801.  
  802.         onPanelChanged(panelBefore, panelAfter) {
  803.             if(this.debug) {
  804.                 console.log(`IP+ onPanelChanged "${panelBefore}" -> "${panelAfter}"`);
  805.             }
  806.             if(panelAfter === "idlepixelplus") {
  807.                 this.refreshPanel("idlepixelplus");
  808.             }
  809.             this.forEachPlugin((plugin) => {
  810.                 if(typeof plugin.onPanelChanged === "function") {
  811.                     plugin.onPanelChanged(panelBefore, panelAfter);
  812.                 }
  813.             });
  814.         }
  815.  
  816.     }
  817.  
  818.     // Add to window and init
  819.     window.IdlePixelPlusPlugin = IdlePixelPlusPlugin;
  820.     window.IdlePixelPlus = new IdlePixelPlus();
  821.     internal.init.call(window.IdlePixelPlus);
  822.  
  823. })();