☰

IdlePixel+

Idle-Pixel plugin framework

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

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

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