☰

BonkLIB

BonkAPI + BonkHUD

  1. // ==UserScript==
  2. // @name         BonkLIB
  3. // @version      1.1.3
  4. // @author       FeiFei + Clarifi + BoZhi
  5. // @namespace    https://github.com/FeiFei-GH/BonkLIB
  6. // @description  BonkAPI + BonkHUD
  7. // @license      MIT
  8. // @match        https://bonk.io/gameframe-release.html
  9. // @run-at       document-start
  10. // @grant        none
  11. // ==/UserScript==
  12. /*
  13. Usable with:
  14. https://greasyfork.org/en/scripts/433861-code-injector-bonk-io
  15. */
  16.  
  17. // ! Compitable with Bonk Version 49
  18. window.bonkLIB = {};
  19. bonkLIB.version = "1.1.3";
  20.  
  21. window.bonkAPI = {};
  22.  
  23. /**
  24.  * Contains data of a single player
  25.  *
  26.  * @typedef {object} Player
  27.  * @property {string} peerID - Peer ID of player
  28.  * @property {string} userName - Username of player
  29.  * @property {number} level - Level of player
  30.  * @property {boolean} guest - Is guest
  31.  * @property {number} team - Integer of what team from 0 to 5
  32.  * @property {boolean} ready - Is ready
  33.  * @property {boolean} tabbed - Is tabbed
  34.  * @property {JSON} avatar - Skin data
  35.  */
  36.  
  37. /**
  38.  * Contains data of a single friend
  39.  *
  40.  * @typedef {object} Friend
  41.  * @property {string} userName - Username of friend
  42.  * @property {string} roomID - Room ID of the lobby that the friend is in
  43.  */
  44.  
  45. // *Global Variables
  46. bonkAPI.currentPlayers = []; //List of user IDs of players in the lobby
  47. bonkAPI.playerList = []; // History list of players in the room
  48. bonkAPI.myID = -1; // Client's ID
  49. bonkAPI.myToken = -1; // Client's token
  50. bonkAPI.hostID = -1; // Host's ID
  51.  
  52. bonkAPI.isLoggingIn = false;
  53.  
  54. // MGF vars
  55. bonkAPI.bonkWSS = 0;
  56. bonkAPI.originalSend = window.WebSocket.prototype.send;
  57. bonkAPI.originalRequestAnimationFrame = window.requestAnimationFrame;
  58. bonkAPI.originalDrawShape = 0;
  59. bonkAPI.pixiCtx = 0;
  60. bonkAPI.pixiStage = 0;
  61. bonkAPI.parentDraw = 0;
  62. bonkAPI.originalXMLOpen = window.XMLHttpRequest.prototype.open;
  63. bonkAPI.originalXMLSend = window.XMLHttpRequest.prototype.send;
  64. window.bonkHUD = {};
  65.  
  66. bonkHUD.windowHold = [];
  67. bonkHUD.settingsHold = [];
  68.  
  69. //! not used but will be
  70. // *Style Store
  71. bonkHUD.styleHold = {};
  72.  
  73. //! styles added do not include color, to be added/changed by user
  74. //! some innercss using these classes still has not been deleted(will do it)
  75. bonkHUD.bonkHUDCSS = document.createElement("style");
  76.  
  77. bonkHUD.bonkHUDCSS.innerHTML = `
  78. .bonkhud-settings-row {
  79.     border-bottom: 1px solid;
  80.     padding: 10px;
  81. }
  82. .bonkhud-settings-label {
  83.     font-size: 0.9rem;
  84.     font-weight: bold;
  85. }
  86. .bonkhud-window-container {
  87.     position: fixed;
  88.     min-width: 5rem;
  89.     font-family: "futurept_b1";
  90.     border-radius: 8px;
  91.     z-index: 9990;
  92. }
  93. .bonkhud-header-button {
  94.     position: absolute;
  95.     top: 3px;
  96.     width: 25px;
  97.     height: 25px;
  98.     border-radius: 3px;
  99. }
  100. .bonkhud-scrollbar-kit::-webkit-scrollbar {
  101.     display: none;
  102. }
  103. .bonkhud-scrollbar-other {
  104.     scrollbar-width: none;
  105. }
  106. .bonkhud-resizer {
  107.     width: 10px;
  108.     height: 10px;
  109.     background: transparent;
  110.     position: absolute;
  111. }
  112. .bonkhud-resizer.north-west {
  113.     top: -5px;
  114.     left: -5px;
  115.     cursor: nwse-resize;
  116. }
  117. .bonkhud-resizer.north-east {
  118.     top: -5px;
  119.     right: -5px;
  120.     cursor: nesw-resize;
  121. }
  122. .bonkhud-resizer.south-east {
  123.     bottom: -5px;
  124.     right: -5px;
  125.     cursor: nwse-resize;
  126. }
  127. .bonkhud-resizer.south-west {
  128.     bottom: -5px;
  129.     left: -5px;
  130.     cursor: nesw-resize;
  131. }
  132. `;
  133.  
  134. document.getElementsByTagName("head")[0].appendChild(bonkHUD.bonkHUDCSS);
  135.  
  136.  
  137. /**
  138.  * Sends message in game's public chat.
  139.  * @function chat
  140.  * @param {string} message - The message.
  141.  */
  142. bonkAPI.chat = function (message) {
  143.     bonkAPI.sendPacket('42[10,{"message":' + JSON.stringify(message) + "}]");
  144. };
  145.  
  146. /**
  147.  * Defaults to banning the player with the given ID.
  148.  * @function banPlayerByID
  149.  * @param {number} id - ID of the player to be kicked/banned
  150.  * @param {boolean} kick - Whether player should be kicked or banned, defaults to false (banned)
  151.  */
  152. bonkAPI.banPlayerByID = function (id, kick = false) {
  153.     bonkAPI.sendPacket('42[9,{"banshortid":' + id + ',"kickonly":' + kick + "}]");
  154. };
  155.  
  156. /**
  157.  * Gets all online friends.
  158.  * @function getOnlineFriendList
  159.  * @param {function} callback - Callback function
  160.  * @returns {Array.<Friend>} Array of {@linkcode Friend} objects
  161.  */
  162. bonkAPI.getOnlineFriendList = function (callback) {
  163.     let req = new window.XMLHttpRequest();
  164.     req.onreadystatechange = () => {
  165.         if (req.readyState == 4) {
  166.             let friends = [];
  167.             let data = JSON.parse(req.response)["friends"];
  168.             for (let i = 0; i < data.length; i++) {
  169.                 let rid = data[i]["roomid"];
  170.                 if (rid != null) {
  171.                     friends.push({ userName: data[i]["name"], roomID: rid });
  172.                 }
  173.             }
  174.             callback(friends);
  175.         }
  176.     };
  177.     try {
  178.         req.open("POST", "https://bonk2.io/scripts/friends.php");
  179.         req.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
  180.         //! maybe make a function to automatically build this stuff, but not necessary and probably worse
  181.         req.send("token=" + bonkAPI.myToken + "&task=getfriends");
  182.     } catch (e) {
  183.         console.log(e);
  184.         callback([]);
  185.     }
  186. };
  187.  
  188. /**
  189.  * Adds a listener to {@linkcode EventHandler} to call the method.
  190.  * @function addEventListener
  191.  * @param {string} event - The event that is listened for
  192.  * @param {function(object)} method - Method that is called when event is fired
  193.  * @param {*} [scope] - Defaults to window
  194.  * @param {*} [context] - Defaults to nothing
  195.  */
  196. bonkAPI.addEventListener = function (event, method, scope, context) {
  197.     bonkAPI.events.addEventListener(event, method, scope, context);
  198. };
  199.  
  200. /**
  201.  * Returns the entire list of {@linkcode Player} objects that have joined
  202.  * since you have.
  203.  * @function getPlayerList
  204.  * @returns {Array.<Player>} Array of {@linkcode Player} objects
  205.  */
  206. bonkAPI.getPlayerList = function () {
  207.     // *Returns a copy of bonkAPI.playerList
  208.     return bonkAPI.playerList;
  209. };
  210.  
  211. /**
  212.  * Returns list of {@linkcode Player} objects in the lobby at time this
  213.  * function was called.
  214.  * @function getPlayerLobbyList
  215.  * @returns {Array.<Player>} Array of {@linkcode Player} objects
  216.  */
  217. bonkAPI.getPlayerLobbyList = function () {
  218.     //! i want to make more playerlobby functions but dk what to name
  219.     //! or whether to join it with the other functions but add an arguement
  220.     //! to specify which to use
  221.     let list = [];
  222.     bonkAPI.currentPlayers.forEach((index) => {
  223.         list.push(bonkAPI.playerList[index]);
  224.     });
  225.     return list;
  226. }
  227.  
  228. /**
  229.  * Returns list of user IDs in the lobby at time this
  230.  * function was called.
  231.  * @function getPlayersInLobbyID
  232.  * @returns {Array.<Player>} Array of {@linkcode Player} objects
  233.  */
  234. bonkAPI.getPlayersInLobbyID = function () {
  235.     return bonkAPI.currentPlayers;
  236. }
  237.  
  238. /**
  239.  * Returns the amount of players that have been in the lobby.
  240.  * @function getPlayerListLength
  241.  * @returns {number} Length of the player list
  242.  */
  243. bonkAPI.getPlayerListLength = function () {
  244.     return bonkAPI.playerList.length;
  245. };
  246.  
  247. /**
  248.  * Returns the {@linkcode Player} object of the ID or name given.
  249.  * @function getPlayer
  250.  * @param {*} ref - Either ID of the player or name of the player
  251.  * @returns {Player} Player object
  252.  */
  253. bonkAPI.getPlayer = function (ref) {
  254.     if (typeof ref === "number") {
  255.         if (ref < 0 || ref >= bonkAPI.playerList.length) {
  256.             return null;
  257.         }
  258.         return bonkAPI.playerList[ref];
  259.     } else if (typeof ref === "string") {
  260.         for (let i = 0; i < bonkAPI.playerList.length; i++) {
  261.             if (bonkAPI.playerList[i] != null && ref == bonkAPI.playerList[i].userName) {
  262.                 return bonkAPI.playerList[i];
  263.             }
  264.         }
  265.         return null;
  266.     } else {
  267.         return null;
  268.     }
  269. };
  270.  
  271. /**
  272.  * Returns the {@linkcode Player} object of the ID given.
  273.  * @function getPlayerByID
  274.  * @param {number} id - ID of the player that is being looked for
  275.  * @returns {Player} Player object
  276.  */
  277. bonkAPI.getPlayerByID = function (id) {
  278.     if (id < 0 || id >= bonkAPI.playerList.length) {
  279.         return null;
  280.     }
  281.     return bonkAPI.playerList[id];
  282. };
  283.  
  284. /**
  285.  * Returns the {@linkcode Player} object of the name given.
  286.  * @function getPlayerByName
  287.  * @param {string} name - Name of the player that is being looked for
  288.  * @returns {Player} Player object
  289.  */
  290. bonkAPI.getPlayerByName = function (name) {
  291.     for (let i = 0; i < bonkAPI.playerList.length; i++) {
  292.         if (bonkAPI.playerList[i] != null && name == bonkAPI.playerList[i].userName) {
  293.             return bonkAPI.playerList[i];
  294.         }
  295.     }
  296.     return null;
  297. };
  298.  
  299. /**
  300.  * Returns the name of the player of the ID given.
  301.  * @function getPlayerNameByID
  302.  * @param id - ID of the player to get the name of
  303.  * @returns {string} Name of player
  304.  */
  305. bonkAPI.getPlayerNameByID = function (id) {
  306.     if (id < 0 || id >= bonkAPI.playerList.length) {
  307.         return "";
  308.     }
  309.     return bonkAPI.playerList[id].userName;
  310. };
  311.  
  312. /**
  313.  * Returns the user ID of the player with the given name.
  314.  * @function getPlayerIDByName
  315.  * @param {string} name - Name of player to get ID of
  316.  * @returns {number} ID of player
  317.  */
  318. bonkAPI.getPlayerIDByName = function (name) {
  319.     for (let i = 0; i < bonkAPI.playerList.length; i++) {
  320.         if (bonkAPI.playerList[i] != null && name == bonkAPI.playerList[i].userName) {
  321.             return i;
  322.         }
  323.     }
  324.     return -1;
  325. };
  326.  
  327. /**
  328.  * Returns a list of {@linkcode Player} objects that are in the specified
  329.  * team.
  330.  * @function getPlayersByTeam
  331.  * @param {number} team - Team of the player, from 0 to 5
  332.  * @returns {Array.<Player>} List of {@linkcode Player} objects
  333.  */
  334. bonkAPI.getPlayersByTeam = function (team) {
  335.     var teamList = [];
  336.     for (let i = 0; i < bonkAPI.playerList.length; i++) {
  337.         if (team == bonkAPI.playerList[i].team) {
  338.             teamList.push({ userID: i, userData: bonkAPI.playerList[i] });
  339.         }
  340.     }
  341.     return teamList;
  342. };
  343.  
  344. /**
  345.  * Returns your own player ID.
  346.  * @function getMyID
  347.  * @returns {number} ID of the user
  348.  */
  349. bonkAPI.getMyID = function () {
  350.     return bonkAPI.myID;
  351. };
  352.  
  353. /**
  354.  * Returns the player ID of the host.
  355.  * @function getHostID
  356.  * @returns {number} ID of the host
  357.  */
  358. bonkAPI.getHostID = function () {
  359.     return bonkAPI.hostID;
  360. };
  361.  
  362. /**
  363.  * Returns whether the capzone can be capped
  364.  * without ending game or desyncing
  365.  * @function safeToCap
  366.  * @returns {boolean} Whether it is safe to cap
  367.  */
  368. bonkAPI.safeToCap = function () {
  369.     if(bonkAPI.currentPlayers.length == 1) {
  370.         return true;
  371.     }
  372.     let t = bonkAPI.playerList[bonkAPI.currentPlayers[0]].team;
  373.     for(let i = 1; i < bonkAPI.currentPlayers.length; i++) {
  374.         if(t != bonkAPI.playerList[bonkAPI.currentPlayers[i]].team && 0 != bonkAPI.playerList[bonkAPI.currentPlayers[i]].team) {
  375.             return false;
  376.         }
  377.     }
  378.     return true;
  379. }
  380.  
  381. /**
  382.  * Returns whether the game is running after
  383.  * you have first joined a lobby.
  384.  * @function isInGame
  385.  * @returns {boolean} Whether in game or not
  386.  */
  387. bonkAPI.isInGame = function () {
  388.     let renderer = document.getElementById("gamerenderer");
  389.     return renderer.style.visibility == "inherit";
  390. }
  391. window.WebSocket.prototype.send = function (args) {
  392.     if (this.url.includes("socket.io/?EIO=3&transport=websocket&sid=")) {
  393.         if (!this.injectedAPI) {
  394.             // initialize overriding receive listener (only run once)
  395.             bonkAPI.bonkWSS = this;
  396.             this.injectedAPI = true;
  397.             var originalReceive = this.onmessage;
  398.             // This function intercepts incoming packets
  399.             this.onmessage = function (args) {
  400.                 // &Receiving incoming packets
  401.                 if(args.data.substring(0, 3) == "42[") {
  402.                     newArgs = JSON.parse(args.data.substring(2));
  403.                     // !All function names follow verb_noun[verb] format
  404.                     switch (parseInt(newArgs[0])) {
  405.                         case 1: //*Update other players' pings
  406.                             newArgs = bonkAPI.receive_PingUpdate(newArgs);
  407.                             break;
  408.                         case 2: // *UNKNOWN, received after sending create room packet
  409.                             newArgs = bonkAPI.receive_Unknow2(newArgs);
  410.                             break;
  411.                         case 3: // *Room Join
  412.                             newArgs = bonkAPI.receive_RoomJoin(newArgs);
  413.                             break;
  414.                         case 4: // *Player Join
  415.                             newArgs = bonkAPI.receive_PlayerJoin(newArgs);
  416.                             break;
  417.                         case 5: // *Player Leave
  418.                             newArgs = bonkAPI.receive_PlayerLeave(newArgs);
  419.                             break;
  420.                         case 6: // *Host Leave
  421.                             newArgs = bonkAPI.receive_HostLeave(newArgs);
  422.                             break;
  423.                         case 7: // *Receive Inputs
  424.                             newArgs = bonkAPI.receive_Inputs(newArgs);
  425.                             break;
  426.                         case 8: // *Ready Change
  427.                             newArgs = bonkAPI.receive_ReadyChange(newArgs);
  428.                             break;
  429.                         case 13: // *Game End
  430.                             newArgs = bonkAPI.receive_GameEnd(newArgs);
  431.                             break;
  432.                         case 15: // *Game Start
  433.                             newArgs = bonkAPI.receive_GameStart(newArgs);
  434.                             break;
  435.                         case 16: // *Error
  436.                             newArgs = bonkAPI.receive_Error(newArgs);
  437.                             break;
  438.                         case 18: // *Team Change
  439.                             newArgs = bonkAPI.receive_TeamChange(newArgs);
  440.                             break;
  441.                         case 19: // *Teamlock Toggle
  442.                             newArgs = bonkAPI.receive_TeamLockToggle(newArgs);
  443.                             break;
  444.                         case 20: // *Chat Message
  445.                             newArgs = bonkAPI.receive_ChatMessage(newArgs);
  446.                             break;
  447.                         case 21: // *Initial Data
  448.                             newArgs = bonkAPI.receive_InitialData(newArgs);
  449.                             break;
  450.                         case 24: // *Kicked
  451.                             newArgs = bonkAPI.receive_PlayerKick(newArgs);
  452.                             break;
  453.                         case 26: // *Change Mode
  454.                             newArgs = bonkAPI.receive_ModeChange(newArgs);
  455.                             break;
  456.                         case 27: // *Change Rounds
  457.                             newArgs = bonkAPI.receive_RoundsChange(newArgs);
  458.                             break;
  459.                         case 29: // *Map Switch
  460.                             newArgs = bonkAPI.receive_MapSwitch(newArgs);
  461.                             break;
  462.                         case 32: // *inactive?
  463.                             newArgs = bonkAPI.receive_Inactive(newArgs);
  464.                             break;
  465.                         case 33: // *Map Suggest
  466.                             newArgs = bonkAPI.receive_MapSuggest(newArgs);
  467.                             break;
  468.                         case 34: // *Map Suggest Client
  469.                             newArgs = bonkAPI.receive_MapSuggestClient(newArgs);
  470.                             break;
  471.                         case 36: // *Player Balance Change
  472.                             newArgs = bonkAPI.receive_PlayerBalance(newArgs);
  473.                             break;
  474.                         case 40: // *Save Replay
  475.                             newArgs = bonkAPI.receive_ReplaySave(newArgs);
  476.                             break;
  477.                         case 41: // *New Host
  478.                             newArgs = bonkAPI.receive_NewHost(newArgs);
  479.                             break;
  480.                         case 42: // *Friend Req
  481.                             newArgs = bonkAPI.receive_FriendRequest(newArgs);
  482.                             break;
  483.                         case 43: // *Game Starting Countdown
  484.                             newArgs = bonkAPI.receive_CountdownStart(newArgs);
  485.                             break;
  486.                         case 44: // *Abort Countdown
  487.                             newArgs = bonkAPI.receive_CountdownAbort(newArgs);
  488.                             break;
  489.                         case 45: // *Player Leveled Up
  490.                             newArgs = bonkAPI.receive_PlayerLevelUp(newArgs);
  491.                             break;
  492.                         case 46: // *Local Gained XP
  493.                             newArgs = bonkAPI.receive_LocalXPGain(newArgs);
  494.                             break;
  495.                         case 48:
  496.                             newArgs = bonkAPI.receive_gameState(newArgs);
  497.                             break;
  498.                         case 49: // *Created Room Share Link
  499.                             newArgs = bonkAPI.receive_RoomShareLink(newArgs);
  500.                             break;
  501.                         case 52: // *Tabbed
  502.                             newArgs = bonkAPI.receive_Tabbed(newArgs);
  503.                             break;
  504.                         case 58: // *Room Name Update
  505.                             newArgs = bonkAPI.receive_RoomName(newArgs);
  506.                             break;
  507.                         case 59: // *Room Password Update
  508.                             newArgs = bonkAPI.receive_RoomPassword(newArgs);
  509.                             break;
  510.                     }
  511.                     args.data = 42 + JSON.stringify(newArgs);
  512.                 }
  513.                 return originalReceive.call(this, args);
  514.             };
  515.  
  516.             var originalClose = this.onclose;
  517.             this.onclose = function () {
  518.                 bonkAPI.bonkWSS = 0;
  519.                 return originalClose.call(this);
  520.             };
  521.         } else {
  522.             // !All function names follow verb_noun[verb] format
  523.             if(args.substring(0, 3) == "42[") {
  524.                 args = JSON.parse(args.substring(2));
  525.                 // &Sending outgoing packets
  526.                 switch (parseInt(args[0])) {
  527.                     case 4: // *Send Inputs
  528.                         args = bonkAPI.send_Inputs(args);
  529.                         break;
  530.                     case 5: // *Trigger Start
  531.                         args = bonkAPI.send_GameStart(args);
  532.                         break;
  533.                     case 6: // *Change Own Team
  534.                         args = bonkAPI.send_TeamChange(args);
  535.                         break;
  536.                     case 7: // *Team Lock
  537.                         args = bonkAPI.send_TeamLock(args);
  538.                         break;
  539.                     case 9: // *Kick/Ban Player
  540.                         args = bonkAPI.send_PlayerKickBan(args);
  541.                         break;
  542.                     case 10: // *Chat Message
  543.                         args = bonkAPI.send_ChatMessage(args);
  544.                         break;
  545.                     case 11: // *Inform In Lobby
  546.                         args = bonkAPI.send_LobbyInform(args);
  547.                         break;
  548.                     case 12: // *Create Room
  549.                         args = bonkAPI.send_RoomCreate(args);
  550.                         break;
  551.                     case 13: // *Room Join Information
  552.                         args = bonkAPI.send_RoomJoin(args);
  553.                         break;
  554.                     case 14: // *Return To Lobby
  555.                         args = bonkAPI.send_LobbyReturn(args);
  556.                         break;
  557.                     case 16: // *Set Ready
  558.                         args = bonkAPI.send_Ready(args);
  559.                         break;
  560.                     case 17: // *All Ready Reset
  561.                         args = bonkAPI.send_AllReadyReset(args);
  562.                         break;
  563.                     case 19: // *Send Map Reorder
  564.                         args = bonkAPI.send_MapReorder(args);
  565.                         break;
  566.                     case 20: // *Send Mode
  567.                         args = bonkAPI.send_ModeChange(args);
  568.                         break;
  569.                     case 21: // *Send WL (Rounds)
  570.                         args = bonkAPI.send_RoundsChange(args);
  571.                         break;
  572.                     case 22: // *Send Map Delete
  573.                         args = bonkAPI.send_MapDelete(args);
  574.                         break;
  575.                     case 23: // *Send Map Switch
  576.                         args = bonkAPI.send_MapSwitch(args);
  577.                         break;
  578.                     case 26: // *Change Other Team
  579.                         args = bonkAPI.send_OtherTeamChange(args);
  580.                         break;
  581.                     case 27: // *Send Map Suggest
  582.                         args = bonkAPI.send_MapSuggest(args);
  583.                         break;
  584.                     case 29: // *Send Balance
  585.                         args = bonkAPI.send_Balance(args);
  586.                         break;
  587.                     case 32: // *Send Team Settings Change
  588.                         args = bonkAPI.send_TeamSetting(args);
  589.                         break;
  590.                     case 33: // *Send Arm Record
  591.                         args = bonkAPI.send_ArmRecord(args);
  592.                         break;
  593.                     case 34: // *Send Host Change
  594.                         args = bonkAPI.send_HostChange(args);
  595.                         break;
  596.                     case 35: // *Send Friended
  597.                         args = bonkAPI.send_Friended(args);
  598.                         break;
  599.                     case 36: // *Send Start Countdown
  600.                         args = bonkAPI.send_CountdownStart(args);
  601.                         break;
  602.                     case 37: // *Send Abort Countdown
  603.                         args = bonkAPI.send_CountdownAbort(args);
  604.                         break;
  605.                     case 38: // *Send Req XP
  606.                         args = bonkAPI.send_XPRequest(args);
  607.                         break;
  608.                     case 39: // *Send Map Vote
  609.                         args = bonkAPI.send_MapVote(args);
  610.                         break;
  611.                     case 40: // *Inform In Game
  612.                         args = bonkAPI.send_InGameInform(args);
  613.                         break;
  614.                     case 41: // *Get Pre Vote
  615.                         args = bonkAPI.send_PreVoteGet(args);
  616.                         break;
  617.                     case 44: // *Tabbed
  618.                         args = bonkAPI.send_Tabbed(args);
  619.                         break;
  620.                     case 50: // *Send No Host Swap
  621.                         args = bonkAPI.send_NoHostSwap(args);
  622.                         break;
  623.                 }
  624.                 args = 42 + JSON.stringify(args);
  625.             }
  626.         }
  627.     }
  628.  
  629.     return bonkAPI.originalSend.call(this, args);
  630. };
  631. /**
  632.  * @class EventHandler
  633.  * @classdesc Stores functions and events and can fire events with data.
  634.  * This class is already instantiated onto bonkAPI so if you dont need your
  635.  * own event handler, ignore this class.
  636.  * @hideconstructor
  637.  */
  638. bonkAPI.EventHandler;
  639. (bonkAPI.EventHandler = function () {
  640.     this.hasEvent = [];
  641. }).prototype = {
  642.     /**
  643.      * Begins to listen for the given event to call the method later.
  644.      * @method
  645.      * @memberof EventHandler
  646.      * @param {string} event - Event that is listened for
  647.      * @param {function(object)} method - Function that is called
  648.      * @param {*} [scope] - Where the function should be called from, defaults to window
  649.      * @param {*} [context] - defaults to nothing
  650.      */
  651.     addEventListener: function (event, method, scope, context) {
  652.         var listeners, handlers;
  653.         if (!(listeners = this.listeners)) {
  654.             listeners = this.listeners = {};
  655.         }
  656.  
  657.         if (!(handlers = listeners[event])) {
  658.             handlers = listeners[event] = [];
  659.             this.hasEvent[event] = true;
  660.         }
  661.  
  662.         scope = scope ? scope : window;
  663.         handlers.push({
  664.             method: method,
  665.             scope: scope,
  666.             context: context ? context : scope,
  667.         });
  668.     },
  669.  
  670.     /**
  671.      * Fires the event given to call the methods linked to that event.
  672.      * @method
  673.      * @memberof EventHandler
  674.      * @param {string} event - Event that is being fired
  675.      * @param {object} data - Data sent along with the event
  676.      * @param {*} [context]
  677.      */
  678.     fireEvent: function (event, data, context) {
  679.         var listeners, handlers, handler, l, scope;
  680.         if (!(listeners = this.listeners)) {
  681.             return;
  682.         }
  683.         if (!(handlers = listeners[event])) {
  684.             return;
  685.         }
  686.         l = handlers.length;
  687.         for (let i = 0; i < l; i++) {
  688.             handler = handlers[i];
  689.             if (typeof context !== "undefined" && context !== handler.context) {
  690.                 continue;
  691.             }
  692.             handler.method.call(handler.scope, data);
  693.         }
  694.     },
  695. };
  696.  
  697. //initialize
  698. bonkAPI.events = new bonkAPI.EventHandler();
  699.  
  700. /**
  701.  * Triggered when recieving ping updates.
  702.  * @function receive_PingUpdate
  703.  * @fires pingUpdate
  704.  * @param {JSON} args - Packet received by websocket.
  705.  * @returns {JSON} arguements
  706.  */
  707. bonkAPI.receive_PingUpdate = function (args) {
  708.     let pingList = args[1];
  709.     let ehcoTo = args[2];
  710.  
  711.     /**
  712.      * When the user receives ping update.
  713.      * @event pingUpdate
  714.      * @type {object}
  715.      * @property {object} pingList - Other players' ping
  716.      * @property {number} echoTo - The ID of the player to echo to
  717.      */
  718.     if (bonkAPI.events.hasEvent["pingUpdate"]) {
  719.         var sendObj = {
  720.             pingList: pingList,
  721.             ehcoTo: ehcoTo,
  722.         };
  723.         bonkAPI.events.fireEvent("pingUpdate", sendObj);
  724.     }
  725.  
  726.     return args;
  727. };
  728.  
  729. bonkAPI.receive_Unknow2 = function (args) {
  730.     //  TODO: Finish implement of function
  731.  
  732.     return args;
  733. };
  734.  
  735. /**
  736.  * Triggered when the user joins a lobby.
  737.  * @function receive_RoomJoin
  738.  * @fires joinRoom
  739.  * @fires playerChange
  740.  * @param {JSON} args - Packet received by websocket.
  741.  * @returns {JSON} arguements
  742.  */
  743. bonkAPI.receive_RoomJoin = function (args) {
  744.     bonkAPI.playerList = [];
  745.     bonkAPI.myID = args[1];
  746.     bonkAPI.hostID = args[2];
  747.  
  748.     for (let i = 0; i < bonkAPI.currentPlayers.length; i++) {
  749.         /**
  750.              * When a player leaves or joins.
  751.              * @event playerChange
  752.              * @type {object}
  753.              * @property {number} userID - ID of the player who joined or left
  754.              * @property {object} userData - Data of the player who joined or left
  755.              * @property {boolean} hasLeft - Whether the player joined or left 
  756.              */
  757.         if (bonkAPI.events.hasEvent["playerChange"]) {
  758.             var sendObj = { userID: bonkAPI.currentPlayers[i], userData: bonkAPI.playerList[bonkAPI.currentPlayers[i]], hasLeft: true };
  759.             bonkAPI.events.fireEvent("playerChange", sendObj);
  760.         }
  761.     }
  762.     bonkAPI.currentPlayers = [];
  763.  
  764.     for (let i = 0; i < args[3].length; i++) {
  765.         bonkAPI.playerList[i] = args[3][i];
  766.         if (args[3][i] != null) {
  767.             bonkAPI.currentPlayers.push(i);
  768.  
  769.             /**
  770.              * When a player leaves or joins.
  771.              * @event playerChange
  772.              * @type {object}
  773.              * @property {number} userID - ID of the player who joined or left
  774.              * @property {object} userData - Data of the player who joined or left
  775.              * @property {boolean} hasLeft - Whether the player joined or left 
  776.              */
  777.             if (bonkAPI.events.hasEvent["playerChange"]) {
  778.                 var sendObj = { userID: args[1], userData: bonkAPI.playerList[args[1]], hasLeft: false };
  779.                 bonkAPI.events.fireEvent("playerChange", sendObj);
  780.             }
  781.         }
  782.     }
  783.     /**
  784.      * When the user joins a lobby.
  785.      * @event joinRoom
  786.      * @type {object}
  787.      * @property {number} hostID - ID of the host
  788.      * @property {Array.<Player>} userData - List of players currently in the room
  789.      * @property {*} roomID - ID of the lobby joined
  790.      * @property {string} bypass
  791.      */
  792.     if (bonkAPI.events.hasEvent["joinRoom"]) {
  793.         var sendObj = {
  794.             hostID: args[2],
  795.             userData: bonkAPI.playerList, // !May or may not be immutable
  796.             roomID: args[6],
  797.             bypass: args[7],
  798.         };
  799.         bonkAPI.events.fireEvent("joinRoom", sendObj);
  800.     }
  801.  
  802.     /**
  803.      * When a player leaves or joins.
  804.      * @event playerChange
  805.      * @type {object}
  806.      * @property {number} userID - ID of the player who joined or left
  807.      * @property {object} userData - Data of the player who joined or left
  808.      * @property {boolean} hasLeft - Whether the player joined or left 
  809.      */
  810.     if (bonkAPI.events.hasEvent["playerChange"]) {
  811.         var sendObj = { userID: args[1], userData: bonkAPI.playerList[args[1]], hasLeft: false };
  812.         bonkAPI.events.fireEvent("playerChange", sendObj);
  813.     }
  814.  
  815.     return args;
  816. };
  817.  
  818. /**
  819.  * Triggered when a player joins the lobby.
  820.  * @function receive_PlayerJoin
  821.  * @fires userJoin
  822.  * @fires playerChange
  823.  * @param {JSON} args - Packet received by websocket.
  824.  * @returns {JSON} arguements
  825.  */
  826. bonkAPI.receive_PlayerJoin = function (args) {
  827.     bonkAPI.playerList[args[1]] = {
  828.         peerId: args[2],
  829.         userName: args[3],
  830.         guest: args[4],
  831.         level: args[5],
  832.         team: args[6],
  833.         ready: false,
  834.         tabbed: false,
  835.         avatar: args[7],
  836.     };
  837.     bonkAPI.currentPlayers.push(args[1]);
  838.  
  839.     //? can:
  840.     //? - send the bonkAPI.playerList as data
  841.     //? - send the new player object as data
  842.     //? - send nothing and let the user access bonkAPI.playerList
  843.     /**
  844.      * When another player joins the lobby.
  845.      * @event userJoin
  846.      * @type {object}
  847.      * @property {number} userID - ID of the player joined
  848.      * @property {Player} userData - {@linkcode Player} object data of the player that joined
  849.      */
  850.     if (bonkAPI.events.hasEvent["userJoin"]) {
  851.         var sendObj = { userID: args[1], userData: bonkAPI.playerList[args[1]] };
  852.         bonkAPI.events.fireEvent("userJoin", sendObj);
  853.     }
  854.  
  855.     /**
  856.      * When a player leaves or joins.
  857.      * @event playerChange
  858.      * @type {object}
  859.      * @property {number} userID - ID of the player who joined or left
  860.      * @property {object} userData - Data of the player who joined or left
  861.      * @property {boolean} hasLeft - Whether the player joined or left 
  862.      */
  863.     if (bonkAPI.events.hasEvent["playerChange"]) {
  864.         var sendObj = { userID: args[1], userData: bonkAPI.playerList[args[1]], hasLeft: false };
  865.         bonkAPI.events.fireEvent("playerChange", sendObj);
  866.     }
  867.  
  868.     return args;
  869. };
  870.  
  871. /**
  872.  * Triggered when a player leaves the lobby.
  873.  * @function receive_PlayerLeave
  874.  * @fires userLeave
  875.  * @fires playerChange
  876.  * @param {JSON} args - Packet received by websocket.
  877.  * @returns {JSON} arguements
  878.  */
  879. bonkAPI.receive_PlayerLeave = function (args) {
  880.     // Remove player from current players
  881.     bonkAPI.currentPlayers.forEach((n, i) => {
  882.         if (n == args[1]) {
  883.             bonkAPI.currentPlayers.splice(i, 1);
  884.         }
  885.     });
  886.  
  887.     /**
  888.      * When another player leaves the lobby.
  889.      * @event userLeave
  890.      * @type {object}
  891.      * @property {number} userID - ID of the player left
  892.      * @property {Player} userData - {@linkcode Player} object data of the player that left
  893.      */
  894.     if (bonkAPI.events.hasEvent["userLeave"]) {
  895.         var sendObj = { userID: args[1], userData: bonkAPI.playerList[args[1]] };
  896.         bonkAPI.events.fireEvent("userLeave", sendObj);
  897.     }
  898.  
  899.     /**
  900.      * When a player leaves or joins.
  901.      * @event playerChange
  902.      * @type {object}
  903.      * @property {number} userID - ID of the player who joined or left
  904.      * @property {object} userData - Data of the player who joined or left
  905.      * @property {boolean} hasLeft - Whether the player joined or left 
  906.      */
  907.     if (bonkAPI.events.hasEvent["playerChange"]) {
  908.         var sendObj = { userID: args[1], userData: bonkAPI.playerList[args[1]], hasLeft: true };
  909.         bonkAPI.events.fireEvent("playerChange", sendObj);
  910.     }
  911.  
  912.     return args;
  913. };
  914.  
  915. /**
  916.  * Triggered when the host has left.
  917.  * @function receive_HostLeave
  918.  * @fires hostChange
  919.  * @fires userLeave
  920.  * @fires playerChange
  921.  * @param {JSON} args - Packet received by websocket.
  922.  * @returns {JSON} arguements
  923.  */
  924. bonkAPI.receive_HostLeave = function (args) {
  925.     let lastHostID = bonkAPI.hostID;
  926.     bonkAPI.hostID = args[2];
  927.  
  928.     // Remove player from current players
  929.     bonkAPI.currentPlayers.forEach((n, i) => {
  930.         if (n == lastHostID) {
  931.             bonkAPI.currentPlayers.splice(i, 1);
  932.         }
  933.     });
  934.  
  935.     /**
  936.      * When the host changes.
  937.      * @event hostChange
  938.      * @type {object}
  939.      * @property {number} userID - ID of the new host
  940.      */
  941.     //Using hostChange to use for multiple cases
  942.     if (bonkAPI.events.hasEvent["hostChange"]) {
  943.         var sendObj = { userID: args[1] };
  944.         bonkAPI.events.fireEvent("hostChange", sendObj);
  945.     }
  946.  
  947.     /**
  948.      * When another player leaves the lobby.
  949.      * @event userLeave
  950.      * @type {object}
  951.      * @property {number} userID - ID of the player left
  952.      * @property {Player} userData - {@linkcode Player} object data of the player that left
  953.      */
  954.     if (bonkAPI.events.hasEvent["userLeave"]) {
  955.         var sendObj = { userID: lastHostID, userData: bonkAPI.playerList[lastHostID] };
  956.         bonkAPI.events.fireEvent("userLeave", sendObj);
  957.     }
  958.  
  959.     /**
  960.      * When a player leaves or joins.
  961.      * @event playerChange
  962.      * @type {object}
  963.      * @property {number} userID - ID of the player who joined or left
  964.      * @property {object} userData - Data of the player who joined or left
  965.      * @property {boolean} hasLeft - Whether the player joined or left 
  966.      */
  967.     if (bonkAPI.events.hasEvent["playerChange"]) {
  968.         var sendObj = { userID: lastHostID, userData: bonkAPI.playerList[lastHostID], hasLeft: true };
  969.         bonkAPI.events.fireEvent("playerChange", sendObj);
  970.     }
  971.  
  972.     return args;
  973. };
  974.  
  975. /**
  976.  * Triggered when a player sends an input.
  977.  * @function receive_Inputs
  978.  * @fires gameInputs
  979.  * @param {JSON} args - Packet received by websocket.
  980.  * @returns {JSON} arguements
  981.  */
  982. bonkAPI.receive_Inputs = function (args) {
  983.     /*
  984.      * Maybe we could have different event names like
  985.      * "receiveRawInput" and "receiveInput" which send
  986.      * different data, the second could have booleans
  987.      * representing the inputs, the other is binary
  988.      */
  989.     /**
  990.      * When inputs are received from other players.
  991.      * @event gameInputs
  992.      * @type {object}
  993.      * @property {number} userID - ID of the player who inputted
  994.      * @property {number} rawInput - Input of the player in the form of 6 bits
  995.      * @property {number} frame - Frame when input happened
  996.      * @property {number} sequence - The total amount of inputs by that player
  997.      */
  998.     if (bonkAPI.events.hasEvent["gameInputs"]) {
  999.         var sendObj = {
  1000.             userID: args[1],
  1001.             rawInput: args[2]["i"],
  1002.             frame: args[2]["f"],
  1003.             sequence: args[2]["c"],
  1004.         };
  1005.         bonkAPI.events.fireEvent("gameInputs", sendObj);
  1006.     } //example
  1007.     /*if(bonkAPI.bonkAPI.events.hasEvent["receiveRawInput"]) {
  1008.         obj here
  1009.         bonkAPI.bonkAPI.events.fireEvent("receiveRawInput", sendObj);
  1010.     }
  1011.     */
  1012.  
  1013.     return args;
  1014. };
  1015.  
  1016. bonkAPI.receive_ReadyChange = function (args) {
  1017.     //  TODO: Finish implement of function
  1018.  
  1019.     return args;
  1020. };
  1021.  
  1022. bonkAPI.receive_GameEnd = function (args) {
  1023.     //  TODO: Finish implement of function
  1024.  
  1025.     return args;
  1026. };
  1027.  
  1028. //! Detects when match starts!!!
  1029. /**
  1030.  * Triggered when the game starts.
  1031.  * @function receive_GameStart
  1032.  * @fires gameStart
  1033.  * @param {JSON} args - Packet received by websocket.
  1034.  * @returns {JSON} arguements
  1035.  */
  1036. bonkAPI.receive_GameStart = function (args) {
  1037.     /**
  1038.      * When game has started
  1039.      * @event gameStart
  1040.      * @type {object}
  1041.      * @property {string} mapData - Encoded map data, must decode it to use
  1042.      * @property {object} startData - Extra game specific data
  1043.      */
  1044.     if (bonkAPI.events.hasEvent["gameStart"] && bonkAPI.myID != bonkAPI.hostID) {
  1045.         //! change name of mapdata since it is not map data, probably gamestate
  1046.         //! do the same in triggerstart
  1047.         var sendObj = {
  1048.             mapData: bonkAPI.ISdecode(args[2]),
  1049.             startData: args[3],
  1050.         };
  1051.         bonkAPI.events.fireEvent("gameStart", sendObj);
  1052.     }
  1053.  
  1054.     return args;
  1055. };
  1056.  
  1057. bonkAPI.receive_Error = function (args) {
  1058.     //  TODO: Finish implement of function
  1059.  
  1060.     return args;
  1061. };
  1062.  
  1063. /**
  1064.  * Triggered when a player changes team.
  1065.  * @function receive_TeamChange
  1066.  * @fires teamChange
  1067.  * @param {JSON} args - Packet received by websocket.
  1068.  * @returns {JSON} arguements
  1069.  */
  1070. bonkAPI.receive_TeamChange = function (args) {
  1071.     bonkAPI.playerList[parseInt(args[1])].team = args[2];
  1072.  
  1073.     /**
  1074.      * When a player has changed teams.
  1075.      * @event teamChange
  1076.      * @type {object}
  1077.      * @property {number} userID - Player who changed teams
  1078.      * @property {number} team - The new team, represented from 0 to 5
  1079.      */
  1080.     if (bonkAPI.events.hasEvent["teamChange"]) {
  1081.         var sendObj = { userID: args[1], team: args[2] };
  1082.         bonkAPI.events.fireEvent("teamChange", sendObj);
  1083.     }
  1084.  
  1085.     return args;
  1086. };
  1087.  
  1088. bonkAPI.receive_TeamLockToggle = function (args) {
  1089.     //  TODO: Finish implement of function
  1090.  
  1091.     return args;
  1092. };
  1093.  
  1094. /**
  1095.  * Triggered when received a message.
  1096.  * @function receive_ChatMessage
  1097.  * @fires chatIn
  1098.  * @param {JSON} args - Packet received by websocket.
  1099.  * @returns {JSON} arguements
  1100.  */
  1101. bonkAPI.receive_ChatMessage = function (args) {
  1102.     let chatUserID = args[1];
  1103.     let chatMessage = args[2];
  1104.  
  1105.     /**
  1106.      * When the user has received a message.
  1107.      * @event chatIn
  1108.      * @type {object}
  1109.      * @property {number} userID - Player who chatted
  1110.      * @property {string} message - The message received
  1111.      */
  1112.     if (bonkAPI.events.hasEvent["chatIn"]) {
  1113.         var sendObj = { userID: chatUserID, message: chatMessage };
  1114.         bonkAPI.events.fireEvent("chatIn", sendObj);
  1115.     }
  1116.  
  1117.     return args;
  1118. };
  1119.  
  1120. /**
  1121.  * Data given by host after join.
  1122.  * @function receive_InitialData
  1123.  * @fires modeChange
  1124.  * @param {JSON} args - Packet received by websocket.
  1125.  * @returns {JSON} arguements
  1126.  */
  1127. bonkAPI.receive_InitialData = function (args) {
  1128.     /**
  1129.      * When the mode has changed.
  1130.      * @event modeChange
  1131.      * @type {object}
  1132.      * @property {string} mode - Short string representing the new mode
  1133.      */
  1134.     if (bonkAPI.events.hasEvent["modeChange"]) {
  1135.         var sendObj = { mode: args[1]["mo"] };
  1136.         bonkAPI.events.fireEvent("modeChange", sendObj);
  1137.     }
  1138.  
  1139.     return args;
  1140. };
  1141.  
  1142. bonkAPI.receive_PlayerKick = function (args) {
  1143.     //  TODO: Finish implement of function
  1144.  
  1145.     return args;
  1146. };
  1147.  
  1148. /**
  1149.  * Triggered when the mode changes.
  1150.  * @function receive_ModeChange
  1151.  * @fires modeChange
  1152.  * @param {JSON} args - Packet received by websocket.
  1153.  * @returns {JSON} arguements
  1154.  */
  1155. bonkAPI.receive_ModeChange = function (args) {
  1156.     // *Maybe change raw arguement to full mode name or numbers
  1157.     /**
  1158.      * When the mode has changed.
  1159.      * @event modeChange
  1160.      * @type {object}
  1161.      * @property {string} mode - Short string representing the new mode
  1162.      */
  1163.     if (bonkAPI.events.hasEvent["modeChange"]) {
  1164.         var sendObj = { mode: args[1] };
  1165.         bonkAPI.events.fireEvent("modeChange", sendObj);
  1166.     }
  1167.  
  1168.     return args;
  1169. };
  1170.  
  1171. bonkAPI.receive_RoundsChange = function (args) {
  1172.     //  TODO: Finish implement of function
  1173.  
  1174.     return args;
  1175. };
  1176.  
  1177. /**
  1178.  * Triggered when map has changed.
  1179.  * @function receive_MapSwitch
  1180.  * @fires mapSwitch
  1181.  * @param {JSON} args - Packet received by websocket.
  1182.  * @returns {JSON} arguements
  1183.  */
  1184. bonkAPI.receive_MapSwitch = function (args) {
  1185.     // *Using mapSwitch to stick with other bonkAPI.events using "change"
  1186.     /**
  1187.      * When the map has changed.
  1188.      * @event mapSwitch
  1189.      * @type {object}
  1190.      * @property {string} mapData - String with the data of the map
  1191.      */
  1192.     if (bonkAPI.events.hasEvent["mapSwitch"]) {
  1193.         var sendObj = { mapData: args[1] };
  1194.         bonkAPI.events.fireEvent("mapSwitch", sendObj);
  1195.     }
  1196.  
  1197.     return args;
  1198. };
  1199.  
  1200. bonkAPI.receive_Inactive = function (args) {
  1201.     //  TODO: Finish implement of function
  1202.  
  1203.     return args;
  1204. };
  1205.  
  1206. bonkAPI.receive_MapSuggest = function (args) {
  1207.     //  TODO: Finish implement of function
  1208.  
  1209.     return args;
  1210. };
  1211.  
  1212. bonkAPI.receive_MapSuggestClient = function (args) {
  1213.     //  TODO: Finish implement of function
  1214.  
  1215.     return args;
  1216. };
  1217.  
  1218. bonkAPI.receive_PlayerBalance = function (args) {
  1219.     //  TODO: Finish implement of function
  1220.  
  1221.     return args;
  1222. };
  1223.  
  1224. bonkAPI.receive_ReplaySave = function (args) {
  1225.     //  TODO: Finish implement of function
  1226.  
  1227.     return args;
  1228. };
  1229.  
  1230. /**
  1231.  * Triggered when there is a new host.
  1232.  * @function receive_NewHost
  1233.  * @fires hostChange
  1234.  * @param {JSON} args - Packet received by websocket.
  1235.  * @returns {JSON} arguements
  1236.  */
  1237. bonkAPI.receive_NewHost = function (args) {
  1238.     bonkAPI.hostID = args[1]["newHost"];
  1239.  
  1240.     /**
  1241.      * When the host changes.
  1242.      * @event hostChange
  1243.      * @type {object}
  1244.      * @property {number} userID - ID of the new host
  1245.      */
  1246.     if (bonkAPI.events.hasEvent["hostChange"]) {
  1247.         var sendObj = { userID: args[1]["newHost"] };
  1248.         bonkAPI.events.fireEvent("hostChange", sendObj);
  1249.     }
  1250.  
  1251.     return args;
  1252. };
  1253.  
  1254. /**
  1255.  * Triggered when the user receives a friend request.
  1256.  * @function receive_FriendReq
  1257.  * @fires receivedFriend
  1258.  * @param {JSON} args - Packet received by websocket.
  1259.  * @returns {JSON} arguements
  1260.  */
  1261. bonkAPI.receive_FriendRequest = function (args) {
  1262.     /**
  1263.      * When the the user has been friended.
  1264.      * @event receivedFriend
  1265.      * @type {object}
  1266.      * @property {number} userID - ID of the player who friended you
  1267.      */
  1268.     if (bonkAPI.events.hasEvent["receivedFriend"]) {
  1269.         var sendObj = { userID: args[1] };
  1270.         bonkAPI.events.fireEvent("receivedFriend", sendObj);
  1271.     }
  1272.  
  1273.     return args;
  1274. };
  1275.  
  1276. bonkAPI.receive_CountdownStart = function (args) {
  1277.     //  TODO: Finish implement of function
  1278.  
  1279.     return args;
  1280. };
  1281.  
  1282. bonkAPI.receive_CountdownAbort = function (args) {
  1283.     //  TODO: Finish implement of function
  1284.  
  1285.     return args;
  1286. };
  1287.  
  1288. bonkAPI.receive_PlayerLevelUp = function (args) {
  1289.     //  TODO: Finish implement of function
  1290.  
  1291.     return args;
  1292. };
  1293.  
  1294. bonkAPI.receive_LocalXPGain = function (args) {
  1295.     //  TODO: Finish implement of function
  1296.  
  1297.     return args;
  1298. };
  1299.  
  1300. /**
  1301.  * Triggers after joining a room and the 
  1302.  * game state is sent.
  1303.  * @function receive_gameState
  1304.  * @fires modeChange
  1305.  * @fires gameStart
  1306.  * @param {JSON} args - Packet received by websocket.
  1307.  * @returns {JSON} arguements
  1308.  */
  1309. bonkAPI.receive_gameState = function (args) {
  1310.     //! also needs to fire something to do with gamestate
  1311.     /**
  1312.      * When the mode has changed.
  1313.      * @event modeChange
  1314.      * @type {object}
  1315.      * @property {string} mode - Short string representing the new mode
  1316.      */
  1317.     if (bonkAPI.events.hasEvent["modeChange"]) {
  1318.         var sendObj = { mode: args[1]["gs"]["mo"] };
  1319.         bonkAPI.events.fireEvent("modeChange", sendObj);
  1320.     }
  1321.  
  1322.     /**
  1323.      * When game has started
  1324.      * @event gameStart
  1325.      * @type {object}
  1326.      * @property {string} mapData - Encoded map data, must decode it to use
  1327.      * @property {object} startData - Extra game specific data
  1328.      */
  1329.     if (bonkAPI.events.hasEvent["gameStart"]) {
  1330.         //! change name of mapdata since it is not map data, probably gamestate
  1331.         //! do the same in triggerstart
  1332.         var sendObj = {
  1333.             mapData: bonkAPI.decodeMap(args[1]["gs"]["map"]),
  1334.             startData: args[3],
  1335.         };
  1336.         bonkAPI.events.fireEvent("gameStart", sendObj);
  1337.     }
  1338.   
  1339.     return args;
  1340. };
  1341.  
  1342. bonkAPI.receive_RoomShareLink = function (args) {
  1343.     //  TODO: Finish implement of function
  1344.  
  1345.     return args;
  1346. };
  1347.  
  1348. bonkAPI.receive_Tabbed = function (args) {
  1349.     //  TODO: Finish implement of function
  1350.  
  1351.     return args;
  1352. };
  1353.  
  1354. bonkAPI.receive_RoomName = function (args) {
  1355.     //  TODO: Finish implement of function
  1356.  
  1357.     return args;
  1358. };
  1359.  
  1360. bonkAPI.receive_RoomPassword = function (args) {
  1361.     //  TODO: Finish implement of function
  1362.  
  1363.     return args;
  1364. };
  1365. /**
  1366.  * Called when sending inputs out.
  1367.  * @function send_Inputs
  1368.  * @param {JSON} args - Packet received by websocket.
  1369.  * @returns {JSON} arguements
  1370.  */
  1371. bonkAPI.send_Inputs = function (args) {
  1372.     /**
  1373.      * When inputs are received from other players.
  1374.      * @event gameInputs
  1375.      * @type {object}
  1376.      * @property {number} userID - ID of the player who inputted
  1377.      * @property {number} rawInput - Input of the player in the form of 6 bits
  1378.      * @property {number} frame - Frame when input happened
  1379.      * @property {number} sequence - The total amount of inputs by that player
  1380.      */
  1381.     if (bonkAPI.events.hasEvent["gameInputs"]) {
  1382.         var sendObj = {
  1383.             userID: bonkAPI.myID,
  1384.             rawInput: args[1]["i"],
  1385.             frame: args[1]["f"],
  1386.             sequence: args[1]["c"],
  1387.         };
  1388.         bonkAPI.events.fireEvent("gameInputs", sendObj);
  1389.     }
  1390.  
  1391.     return args;
  1392. };
  1393.  
  1394. /**
  1395.  * Called when started the game.
  1396.  * @function send_GameStart
  1397.  * @param {JSON} args - Packet received by websocket.
  1398.  * @returns {JSON} arguements
  1399.  */
  1400. bonkAPI.send_GameStart = function (args) {
  1401.     /**
  1402.      * When game has started
  1403.      * @event gameStart
  1404.      * @type {object}
  1405.      * @property {string} mapData - Encoded map data, must decode it to use
  1406.      * @property {object} startData - Extra game specific data
  1407.      */
  1408.     if (bonkAPI.events.hasEvent["gameStart"]) {
  1409.         //! do something to mapData so it will encode it
  1410.         //! then assign it back to the args
  1411.         var sendObj = {
  1412.             mapData: bonkAPI.ISdecode(args[1]["is"]),
  1413.             startData: args[1]["gs"],
  1414.         };
  1415.         bonkAPI.events.fireEvent("gameStart", sendObj);
  1416.  
  1417.         //!possibly temporary
  1418.         //allows start packet to be edited
  1419.         args[1]["is"] = bonkAPI.ISencode(sendObj.mapData);
  1420.     }
  1421.  
  1422.     return args;
  1423. };
  1424.  
  1425. bonkAPI.send_TeamChange = function (args) {
  1426.     //  TODO: Finish implement of function
  1427.  
  1428.     return args;
  1429. };
  1430.  
  1431. bonkAPI.send_TeamLock = function (args) {
  1432.     //  TODO: Finish implement of function
  1433.  
  1434.     return args;
  1435. };
  1436.  
  1437. bonkAPI.send_PlayerKickBan = function (args) {
  1438.     //  TODO: Finish implement of function
  1439.  
  1440.     return args;
  1441. };
  1442.  
  1443. bonkAPI.send_ChatMessage = function (args) {
  1444.     //  TODO: Finish implement of function
  1445.  
  1446.     return args;
  1447. };
  1448.  
  1449. bonkAPI.send_LobbyInform = function (args) {
  1450.     //  TODO: Finish implement of function
  1451.  
  1452.     return args;
  1453. };
  1454.  
  1455. /**
  1456.  * Called when created a room.
  1457.  * @function send_RoomCreate
  1458.  * @fires createRoom
  1459.  * @fires playerChange
  1460.  * @param {JSON} args - Packet received by websocket.
  1461.  * @returns {JSON} arguements
  1462.  */
  1463. bonkAPI.send_RoomCreate = function (args) {
  1464.     bonkAPI.playerList = [];
  1465.  
  1466.     for (let i = 0; i < bonkAPI.currentPlayers.length; i++) {
  1467.         /**
  1468.          * When a player leaves or joins.
  1469.          * @event playerChange
  1470.          * @type {object}
  1471.          * @property {number} userID - ID of the player who joined or left
  1472.          * @property {object} userData - Data of the player who joined or left
  1473.          * @property {boolean} hasLeft - Whether the player joined or left
  1474.          */
  1475.         if (bonkAPI.events.hasEvent["playerChange"]) {
  1476.             var sendObj = { userID: bonkAPI.currentPlayers[i], userData: bonkAPI.playerList[bonkAPI.currentPlayers[i]], hasLeft: true };
  1477.             bonkAPI.events.fireEvent("playerChange", sendObj);
  1478.         }
  1479.     }
  1480.     bonkAPI.currentPlayers = [];
  1481.  
  1482.     bonkAPI.playerList[0] = {
  1483.         peerId: args[1]["peerID"],
  1484.         userName: document.getElementById("pretty_top_name").textContent,
  1485.         level:
  1486.             document.getElementById("pretty_top_level").textContent == "Guest"
  1487.                 ? 0
  1488.                 : parseInt(document.getElementById("pretty_top_level").textContent.substring(3)),
  1489.         guest: typeof args[1].token == "undefined",
  1490.         team: 1,
  1491.         ready: false,
  1492.         tabbed: false,
  1493.         avatar: args[1]["avatar"],
  1494.     };
  1495.     bonkAPI.currentPlayers.push(0);
  1496.  
  1497.     bonkAPI.myID = 0;
  1498.     bonkAPI.hostID = 0;
  1499.  
  1500.     /**
  1501.      * When you create a room.
  1502.      * @event createRoom
  1503.      * @type {object}
  1504.      * @property {number} userID - ID of you
  1505.      * @property {object} userData - Your player data
  1506.      */
  1507.     if (bonkAPI.events.hasEvent["createRoom"]) {
  1508.         var sendObj = { userID: 0, userData: bonkAPI.playerList[0] };
  1509.         bonkAPI.events.fireEvent("createRoom", sendObj);
  1510.     }
  1511.  
  1512.     /**
  1513.      * When a player leaves or joins.
  1514.      * @event playerChange
  1515.      * @type {object}
  1516.      * @property {number} userID - ID of the player who joined or left
  1517.      * @property {object} userData - Data of the player who joined or left
  1518.      * @property {boolean} hasLeft - Whether the player joined or left
  1519.      */
  1520.     if (bonkAPI.events.hasEvent["playerChange"]) {
  1521.         var sendObj = { userID: 0, userData: bonkAPI.playerList[0], hasLeft: false };
  1522.         bonkAPI.events.fireEvent("playerChange", sendObj);
  1523.     }
  1524.  
  1525.     return args;
  1526. };
  1527.  
  1528. /**
  1529.  * Called as to send inital user data when joining a room.
  1530.  * @function send_RoomJoin
  1531.  * @fires roomJoin
  1532.  * @param {JSON} args - Packet received by websocket.
  1533.  * @returns {JSON} arguements
  1534.  */
  1535. bonkAPI.send_RoomJoin = function (args) {
  1536.     //! DONT KNOW WHAT TO DO FOR NAMING
  1537.     //! Possibly get rid of XMLhttp thing since this gives the login token
  1538.     /**
  1539.      * When inputs are received from other players.
  1540.      * @event roomJoin
  1541.      * @type {object}
  1542.      * @property {string} password - Room password
  1543.      * @property {object} avatar - User's avatar
  1544.      * @property {string} token - Login token
  1545.      */
  1546.     if (bonkAPI.events.hasEvent["roomJoin"]) {
  1547.         var sendObj = {
  1548.             password: args[1]["roomPassword"],
  1549.             avatar: args[1]["avatar"],
  1550.             token: args[1]["token"] ? args[1]["token"] : null,
  1551.         };
  1552.         bonkAPI.events.fireEvent("roomJoin", sendObj);
  1553.     }
  1554.  
  1555.     return args;
  1556. };
  1557.  
  1558. bonkAPI.send_LobbyReturn = function (args) {
  1559.     //  TODO: Finish implement of function
  1560.  
  1561.     return args;
  1562. };
  1563.  
  1564. bonkAPI.send_Ready = function (args) {
  1565.     //  TODO: Finish implement of function
  1566.  
  1567.     return args;
  1568. };
  1569.  
  1570. bonkAPI.send_AllReadyReset = function (args) {
  1571.     //  TODO: Finish implement of function
  1572.  
  1573.     return args;
  1574. };
  1575.  
  1576. bonkAPI.send_MapReorder = function (args) {
  1577.     //  TODO: Finish implement of function
  1578.  
  1579.     return args;
  1580. };
  1581.  
  1582. /**
  1583.  * When you change modes.
  1584.  * @function send_ModeChange
  1585.  * @fires modeChange
  1586.  * @param {JSON} args - Packet received by websocket.
  1587.  * @returns {JSON} arguements
  1588.  */
  1589. bonkAPI.send_ModeChange = function (args) {
  1590.     //  TODO: Finish implement of function
  1591.     /**
  1592.      * When the mode has changed.
  1593.      * @event modeChange
  1594.      * @type {object}
  1595.      * @property {string} mode - Short string representing the new mode
  1596.      */
  1597.     if (bonkAPI.events.hasEvent["modeChange"]) {
  1598.         var sendObj = { mode: args[1]["mo"] };
  1599.         bonkAPI.events.fireEvent("modeChange", sendObj);
  1600.     }
  1601.  
  1602.     return args;
  1603. };
  1604.  
  1605. bonkAPI.send_RoundsChange = function (args) {
  1606.     //  TODO: Finish implement of function
  1607.  
  1608.     return args;
  1609. };
  1610.  
  1611. bonkAPI.send_MapDelete = function (args) {
  1612.     //  TODO: Finish implement of function
  1613.  
  1614.     return args;
  1615. };
  1616.  
  1617. /**
  1618.  * Called when user changes map.
  1619.  * @function send_MapSwitch
  1620.  * @param {JSON} args - Packet received by websocket.
  1621.  * @returns {JSON} arguements
  1622.  */
  1623. bonkAPI.send_MapSwitch = function (args) {
  1624.     // *Using mapSwitch to stick with other bonkAPI.events using "change"
  1625.     /**
  1626.      * When the map has changed.
  1627.      * @event mapSwitch
  1628.      * @type {object}
  1629.      * @property {string} mapData - String with the data of the map
  1630.      */
  1631.     if (bonkAPI.events.hasEvent["mapSwitch"]) {
  1632.         var sendObj = { mapData: args[1]["m"] };
  1633.         bonkAPI.events.fireEvent("mapSwitch", sendObj);
  1634.     }
  1635.     return args;
  1636. };
  1637.  
  1638. bonkAPI.send_OtherTeamChange = function (args) {
  1639.     //  TODO: Finish implement of function
  1640.  
  1641.     return args;
  1642. };
  1643.  
  1644. bonkAPI.send_MapSuggest = function (args) {
  1645.     //  TODO: Finish implement of function
  1646.  
  1647.     return args;
  1648. };
  1649.  
  1650. bonkAPI.send_Balance = function (args) {
  1651.     //  TODO: Finish implement of function
  1652.  
  1653.     return args;
  1654. };
  1655.  
  1656. bonkAPI.send_TeamSetting = function (args) {
  1657.     //  TODO: Finish implement of function
  1658.  
  1659.     return args;
  1660. };
  1661.  
  1662. bonkAPI.send_ArmRecord = function (args) {
  1663.     //  TODO: Finish implement of function
  1664.  
  1665.     return args;
  1666. };
  1667.  
  1668. bonkAPI.send_HostChange = function (args) {
  1669.     //  TODO: Finish implement of function
  1670.  
  1671.     return args;
  1672. };
  1673.  
  1674. bonkAPI.send_Friended = function (args) {
  1675.     //  TODO: Finish implement of function
  1676.  
  1677.     return args;
  1678. };
  1679.  
  1680. bonkAPI.send_CountdownStart = function (args) {
  1681.     //  TODO: Finish implement of function
  1682.  
  1683.     return args;
  1684. };
  1685.  
  1686. bonkAPI.send_CountdownAbort = function (args) {
  1687.     //  TODO: Finish implement of function
  1688.  
  1689.     return args;
  1690. };
  1691.  
  1692. bonkAPI.send_XPRequest = function (args) {
  1693.     //  TODO: Finish implement of function
  1694.  
  1695.     return args;
  1696. };
  1697.  
  1698. bonkAPI.send_MapVote = function (args) {
  1699.     //  TODO: Finish implement of function
  1700.  
  1701.     return args;
  1702. };
  1703.  
  1704. bonkAPI.send_InGameInform = function (args) {
  1705.     //  TODO: Finish implement of function
  1706.  
  1707.     return args;
  1708. };
  1709.  
  1710. bonkAPI.send_PreVoteGet = function (args) {
  1711.     //  TODO: Finish implement of function
  1712.  
  1713.     return args;
  1714. };
  1715.  
  1716. bonkAPI.send_Tabbed = function (args) {
  1717.     //  TODO: Finish implement of function
  1718.  
  1719.     return args;
  1720. };
  1721.  
  1722. bonkAPI.send_NoHostSwap = function (args) {
  1723.     //  TODO: Finish implement of function
  1724.  
  1725.     return args;
  1726. };
  1727. window.XMLHttpRequest.prototype.open = function (_, url) {
  1728.     if (url.includes("scripts/login_legacy")) {
  1729.         bonkAPI.isLoggingIn = true;
  1730.     }
  1731.     //? Could check for other post requests but not necessary
  1732.  
  1733.     bonkAPI.originalXMLOpen.call(this, ...arguments);
  1734. };
  1735. window.XMLHttpRequest.prototype.send = function (data) {
  1736.     if (bonkAPI.isLoggingIn) {
  1737.         this.onreadystatechange = function () {
  1738.             if (this.readyState == 4) {
  1739.                 bonkAPI.myToken = JSON.parse(this.response)["token"];
  1740.             }
  1741.         };
  1742.         bonkAPI.isLoggingIn = false;
  1743.     }
  1744.     bonkAPI.originalXMLSend.call(this, ...arguments);
  1745. };
  1746. // *Injecting code into src
  1747. bonkAPI.injector = function (src) {
  1748.     let newSrc = src;
  1749.  
  1750.     //! Inject capZoneEvent fire
  1751.     let orgCode = `K$h[9]=K$h[0][0][K$h[2][138]]()[K$h[2][115]];`;
  1752.     let newCode = `
  1753.         K$h[9]=K$h[0][0][K$h[2][138]]()[K$h[2][115]];
  1754.         
  1755.         bonkAPI_capZoneEventTry: try {
  1756.             // Initialize
  1757.             let inputState = z0M[0][0];
  1758.             let currentFrame = inputState.rl;
  1759.             let playerID = K$h[0][0].m_userData.arrayID;
  1760.             let capID = K$h[1];
  1761.             
  1762.             let sendObj = { capID: capID, playerID: playerID, currentFrame: currentFrame };
  1763.             
  1764.             if (window.bonkAPI.events.hasEvent["capZoneEvent"]) {
  1765.                 window.bonkAPI.events.fireEvent("capZoneEvent", sendObj);
  1766.             }
  1767.         } catch(err) {
  1768.             console.error("ERROR: capZoneEvent");
  1769.             console.error(err);
  1770.         }`;
  1771.  
  1772.     newSrc = newSrc.replace(orgCode, newCode);
  1773.  
  1774.     //! Inject stepEvent fire
  1775.     orgCode = `return z0M[720];`;
  1776.     newCode = `
  1777.         bonkAPI_stepEventTry: try {
  1778.             let inputStateClone = JSON.parse(JSON.stringify(z0M[0][0]));
  1779.             let currentFrame = inputStateClone.rl;
  1780.             let gameStateClone = JSON.parse(JSON.stringify(z0M[720]));
  1781.             
  1782.             let sendObj = { inputState: inputStateClone, gameState: gameStateClone, currentFrame: currentFrame };
  1783.             
  1784.             if (window.bonkAPI.events.hasEvent["stepEvent"]) {
  1785.                 window.bonkAPI.events.fireEvent("stepEvent", sendObj);
  1786.             }
  1787.         } catch(err) {
  1788.             console.error("ERROR: stepEvent");
  1789.             console.error(err);
  1790.         }
  1791.         
  1792.         return z0M[720];`;
  1793.  
  1794.     newSrc = newSrc.replace(orgCode, newCode);
  1795.  
  1796.     //! Inject frameIncEvent fire
  1797.     //TODO: update to bonk 49
  1798.     orgCode = `Y3z[8]++;`;
  1799.     newCode = `
  1800.         Y3z[8]++;
  1801.         
  1802.         bonkAPI_frameIncEventTry: try {
  1803.             if (window.bonkAPI.events.hasEvent["frameIncEvent"]) {
  1804.                 var sendObj = { frame: Y3z[8], gameStates: o3x[7] };
  1805.                 
  1806.                 window.bonkAPI.events.fireEvent("frameIncEvent", sendObj);
  1807.             }
  1808.         } catch(err) {
  1809.             console.error("ERROR: frameIncEvent");
  1810.             console.error(err);
  1811.         }`;
  1812.  
  1813.     // newSrc = newSrc.replace(orgCode, newCode);
  1814.     return newSrc;
  1815. };
  1816.  
  1817. // Compatibility with Excigma's code injector userscript
  1818. if (!window.bonkCodeInjectors) window.bonkCodeInjectors = [];
  1819. window.bonkCodeInjectors.push((bonkCode) => {
  1820.     try {
  1821.         return bonkAPI.injector(bonkCode);
  1822.     } catch (error) {
  1823.         alert(`Injecting failed, BonkAPI may lose some functionality. This may be due to an update by Chaz.`);
  1824.         throw error;
  1825.     }
  1826. });
  1827. // TODO: these could be dangerous, maybe add some sanitization
  1828. // *Send a packet to server
  1829. /**
  1830.  * Sends the given packet to bonk servers.
  1831.  * @function bonkAPI.sendPacket
  1832.  * @param {string} packet - Packet to send to bonk
  1833.  */
  1834. bonkAPI.sendPacket = function (packet) {
  1835.     if (bonkAPI.bonkWSS != 0) {
  1836.         bonkAPI.bonkWSS.send(packet);
  1837.     }
  1838. };
  1839.  
  1840. // *Make client receive a packet
  1841. /**
  1842.  * Makes your client receive the given packet.
  1843.  * @function bonkAPI.receivePacket
  1844.  * @param {string} packet - Packet that is received
  1845.  */
  1846. bonkAPI.receivePacket = function (packet) {
  1847.     if (bonkAPI.bonkWSS != 0) {
  1848.         bonkAPI.bonkWSS.onmessage({ data: packet });
  1849.     }
  1850. };
  1851. bonkHUD.createWindow = function (windowName, windowContent, opts = {}) {
  1852.     //* leaving this for backwards compatability fr
  1853.     let id = "bonkHUD_window_" + windowName; 
  1854.     let modVersion = "1.0.0";
  1855.     if(opts.hasOwnProperty("windowId")) {
  1856.         id = opts.windowId
  1857.     }
  1858.     if(opts.hasOwnProperty("modVersion")) {
  1859.         modVersion = opts.modVersion
  1860.     }
  1861.     if(opts.hasOwnProperty("bonkLIBVersion")) {
  1862.         if(opts.bonkLIBVersion != bonkLIB.version) {
  1863.             if(typeof opts.bonkLIBVersion === 'string') {
  1864.                 if(opts.bonkLIBVersion.substring(0, opts.bonkLIBVersion.lastIndexOf(".")) != bonkLIB.version.substring(0, bonkLIB.version.lastIndexOf(".")))
  1865.                     alert(windowName + " may not be compatible with current version of BonkLIB ("+opts.bonkLIBVersion+" =/= "+bonkLIB.version+")");
  1866.                 console.log(windowName + " may not be compatible with current version of BonkLIB ("+opts.bonkLIBVersion+" =/= "+bonkLIB.version+")");
  1867.             }
  1868.             else {
  1869.                 alert("Version is incompatible, please check with mod maker to fix");
  1870.             }
  1871.         }
  1872.     }
  1873.     //! ignoring for now
  1874.     /*if(opts.hasOwnProperty("bonkVersion")) {
  1875.         
  1876.     }*/
  1877.     let idCounter = 0
  1878.     while(document.getElementById(id) != null) {
  1879.         id = "bonkHUD_window_" + windowName + idCounter
  1880.         idCounter++
  1881.     }
  1882.  
  1883.     //(name, id, recVersion, bodyHTML, settingElement = 0) {
  1884.     let ind = bonkHUD.settingsHold.length;
  1885.     bonkHUD.settingsHold.push(id)
  1886.     bonkHUD.windowHold[ind] = { id: id };
  1887.     bonkHUD.windowHold[ind] = bonkHUD.getUISetting(ind)
  1888.  
  1889.     // Create Settings controller
  1890.     let fullSettingsDiv = document.createElement("div");
  1891.     bonkHUD.createWindowControl(ind, fullSettingsDiv);
  1892.     if(opts.hasOwnProperty("settingsContent")) {
  1893.         bonkHUD.createSettingsControl(opts.settingsContent, fullSettingsDiv);
  1894.     }
  1895.     bonkHUD.createMenuHeader(windowName, fullSettingsDiv, modVersion);
  1896.  
  1897.     //! POSSIBLY MOVE EVERYTHING ABOVE TO createMod TO MAKE CLEANER BUT NOT BACKWARDS COMPATIBLE
  1898.     // Create the main container 'dragItem'
  1899.     let dragItem = document.createElement("div");
  1900.     dragItem.classList.add("bonkhud-window-container");
  1901.     dragItem.classList.add("bonkhud-background-color");
  1902.     dragItem.classList.add("windowShadow");
  1903.     dragItem.id = id + "-drag";
  1904.     dragItem.style.overflowX = "hidden";
  1905.     dragItem.style.overflowY = "hidden";
  1906.     dragItem.style.bottom = bonkHUD.windowHold[ind].bottom; //top ? top : "0";
  1907.     dragItem.style.right = bonkHUD.windowHold[ind].right; //left ? left : "0";
  1908.     dragItem.style.width = bonkHUD.windowHold[ind].width; //width ? width : "172";
  1909.     dragItem.style.height = bonkHUD.windowHold[ind].height; //height ? height : minHeight;
  1910.     //dragItem.style.minHeight = minHeight; // Minimum height to prevent deformation
  1911.     dragItem.style.display = bonkHUD.windowHold[ind].display;
  1912.     dragItem.style.visibility = "visible";
  1913.     dragItem.style.opacity = bonkHUD.windowHold[ind].opacity;
  1914.  
  1915.     let dragNW = document.createElement("div");
  1916.     dragNW.classList.add("bonkhud-resizer");
  1917.     dragNW.classList.add("north-west");
  1918.  
  1919.     let dragNE = document.createElement("div");
  1920.     dragNE.classList.add("bonkhud-resizer");
  1921.     dragNE.classList.add("north-east");
  1922.  
  1923.     let dragSE = document.createElement("div");
  1924.     dragSE.classList.add("bonkhud-resizer");
  1925.     dragSE.classList.add("south-east");
  1926.  
  1927.     let dragSW = document.createElement("div");
  1928.     dragSW.classList.add("bonkhud-resizer");
  1929.     dragSW.classList.add("south-west");
  1930.  
  1931.     // Create the header
  1932.     let header = document.createElement("div");
  1933.     header.classList.add("bonkhud-drag-header");
  1934.     header.classList.add("newbonklobby_boxtop");
  1935.     header.classList.add("newbonklobby_boxtop_classic");
  1936.     header.classList.add("bonkhud-header-color");
  1937.     header.style.borderRadius = "0px";
  1938.     header.style.visibility = "visible";
  1939.  
  1940.     // Create the title span
  1941.     let title = document.createElement("span");
  1942.     title.classList.add("bonkhud-drag-header");
  1943.     title.classList.add("bonkhud-title-color");
  1944.     title.textContent = windowName;
  1945.     title.style.flexGrow = "1";
  1946.     title.style.textAlign = "center";
  1947.  
  1948.     // Create the resize button
  1949.     let openCloseButton = document.createElement("div");
  1950.     openCloseButton.classList.add("bonkhud-header-button");
  1951.     openCloseButton.classList.add("bonkhud-title-color");
  1952.     openCloseButton.classList.add("bonkhud-resize");
  1953.     openCloseButton.innerText = "△"; // Use an appropriate icon or text
  1954.     openCloseButton.style.fontSize = "15px";
  1955.     openCloseButton.style.lineHeight = "25px";
  1956.     openCloseButton.style.textIndent = "5px";
  1957.     openCloseButton.style.cursor = "cell";
  1958.  
  1959.     let closeButton = document.createElement("div");
  1960.     closeButton.classList.add("bonkhud-header-button");
  1961.     closeButton.classList.add("bonkhud-title-color");
  1962.     closeButton.innerText = "_"; // Use an appropriate icon or text
  1963.     closeButton.style.lineHeight = "9px";
  1964.     closeButton.style.right = "3px";
  1965.     closeButton.style.cursor = "pointer";
  1966.  
  1967.     // Append the title and resize button to the header
  1968.     header.appendChild(title);
  1969.     header.appendChild(openCloseButton);
  1970.     header.appendChild(closeButton);
  1971.  
  1972.     // Append the header to the dragItem
  1973.     dragItem.appendChild(dragNW);
  1974.     dragItem.appendChild(dragNE);
  1975.     dragItem.appendChild(dragSE);
  1976.     dragItem.appendChild(dragSW);
  1977.     dragItem.appendChild(header);
  1978.  
  1979.     // Create the key table
  1980.     windowContent.id = id;
  1981.     windowContent.classList.add("bonkhud-text-color");
  1982.     windowContent.classList.add("bonkhud-scrollbar-kit");
  1983.     windowContent.classList.add("bonkhud-scrollbar-other");
  1984.     windowContent.style.overflowY = "scroll";
  1985.     windowContent.style.padding = "5px";
  1986.     windowContent.style.width = "calc(100% - 10px)";
  1987.     windowContent.style.height = "calc(100% - 42px)"; // Adjusted height for header
  1988.  
  1989.     // Append the content to the dragItem
  1990.     dragItem.appendChild(windowContent);
  1991.  
  1992.     // Append the dragItem to the body of the page
  1993.     document.body.appendChild(dragItem);
  1994.  
  1995.     closeButton.addEventListener('click', (e) => {
  1996.         dragItem.style.display = "none";
  1997.         let visCheck = document.getElementById(id + "-visibility-check");
  1998.         visCheck.checked = false;
  1999.         bonkHUD.windowHold[ind].display = dragItem.style.display;
  2000.         bonkHUD.saveUISetting(ind);
  2001.     });
  2002.  
  2003.     // Add event listeners for dragging
  2004.     dragItem.addEventListener('mousedown', (e) => bonkHUD.dragStart(e, dragItem, ind));
  2005.  
  2006.     // Add event listeners for resizing
  2007.     openCloseButton.addEventListener('mousedown', (e) => {
  2008.         if(openCloseButton.innerText == "△") {
  2009.             dragItem.style.visibility = "hidden";
  2010.             header.style.borderRadius = "8px";
  2011.             openCloseButton.innerText = "▽";
  2012.         } else {
  2013.             dragItem.style.visibility = "visible";
  2014.             header.style.borderRadius = "0px";
  2015.             openCloseButton.innerText = "△";
  2016.         }
  2017.     });
  2018.     dragNW.addEventListener('mousedown', (e) => bonkHUD.startResizing(e, dragItem, "nw", ind));
  2019.     dragNE.addEventListener('mousedown', (e) => bonkHUD.startResizing(e, dragItem, "ne", ind));
  2020.     dragSE.addEventListener('mousedown', (e) => bonkHUD.startResizing(e, dragItem, "se", ind));
  2021.     dragSW.addEventListener('mousedown', (e) => bonkHUD.startResizing(e, dragItem, "sw", ind));
  2022.  
  2023.     bonkHUD.updateStyleSettings(); //! probably slow but it works, its not like someone will have 100's of windows
  2024.  
  2025.     return ind;
  2026. };
  2027.  
  2028. bonkHUD.createMod = function (modName, opts = {}) {
  2029.     if(opts.hasOwnProperty("bonkLIBVersion")) {
  2030.         if(opts.bonkLIBVersion != bonkLIB.version) {
  2031.             if(typeof opts.bonkLIBVersion === 'string') {
  2032.                 if(opts.bonkLIBVersion.substring(0, opts.bonkLIBVersion.lastIndexOf(".")) != bonkLIB.version.substring(0, bonkLIB.version.lastIndexOf(".")))
  2033.                     alert(windowName + " may not be compatible with current version of BonkLIB ("+opts.bonkLIBVersion+" =/= "+bonkLIB.version+")");
  2034.                 console.log(windowName + " may not be compatible with current version of BonkLIB ("+opts.bonkLIBVersion+" =/= "+bonkLIB.version+")");
  2035.             }
  2036.             else {
  2037.                 alert("Version is incompatible, please check with mod maker to fix");
  2038.             }
  2039.         }
  2040.     }
  2041.  
  2042.     if(opts.hasOwnProperty("noWindow") && opts.noWindow) {
  2043.         let id = modName;
  2044.         let modVersion = "1.0.0";
  2045.         if(opts.hasOwnProperty("modVersion")) {
  2046.             modVersion = opts.modVersion;
  2047.         }
  2048.  
  2049.         let ind = bonkHUD.settingsHold.length;
  2050.         bonkHUD.settingsHold.push(id)
  2051.  
  2052.         // Create Settings controller
  2053.         let fullSettingsDiv = document.createElement("div");
  2054.         if(opts.hasOwnProperty("settingsContent")) {
  2055.             bonkHUD.createSettingsControl(opts.settingsContent, fullSettingsDiv);
  2056.         }
  2057.         bonkHUD.createMenuHeader(modName, fullSettingsDiv, modVersion);
  2058.         return ind;
  2059.     } else {
  2060.         if(opts.hasOwnProperty("windowContent")) {
  2061.             return bonkHUD.createWindow(modName, opts.windowContent, opts);
  2062.         }
  2063.     }
  2064. };
  2065. bonkHUD.dragStart = function (e, dragItem, ind) {
  2066.     bonkHUD.focusWindow(dragItem);
  2067.     // Prevents dragging from starting on the opacity slider
  2068.     if (e.target.classList.contains("bonkhud-drag-header") && !e.target.classList.contains("bonkhud-resize")) {
  2069.         let startX = e.clientX;
  2070.         let startY = e.clientY;
  2071.         let startRight = parseInt(window.getComputedStyle(dragItem).right, 10);
  2072.         let startBottom = parseInt(window.getComputedStyle(dragItem).bottom, 10);
  2073.         const boundDragMove = bonkHUD.dragMove.bind(null, startX, startY, startRight, startBottom, dragItem);
  2074.         document.addEventListener('mousemove', boundDragMove);
  2075.         document.addEventListener('mouseup', () => bonkHUD.dragEnd(boundDragMove, dragItem, ind), { once: true });
  2076.     }
  2077. };
  2078.  
  2079. bonkHUD.dragMove = function (startX, startY, startRight, startBottom, dragItem, e) {
  2080.     let w = parseFloat(window.getComputedStyle(dragItem).width) / 2;
  2081.     let h = parseFloat(window.getComputedStyle(dragItem).height) / 2;
  2082.     let moveX = bonkHUD.clamp(startRight + startX - e.clientX, -w, window.innerWidth - w);
  2083.     let moveY = bonkHUD.clamp(startBottom + startY - e.clientY, -h, window.innerHeight - h * 2 + 15);
  2084.     dragItem.style.right = bonkHUD.pxTorem(moveX) + "rem";
  2085.     dragItem.style.bottom = bonkHUD.pxTorem(moveY) + "rem";
  2086. };
  2087.  
  2088. bonkHUD.dragEnd = function (dragMoveFn, dragItem, ind) {
  2089.     document.removeEventListener('mousemove', dragMoveFn);
  2090.     bonkHUD.windowHold[ind].width = dragItem.style.width;
  2091.     bonkHUD.windowHold[ind].height = dragItem.style.height;
  2092.     bonkHUD.windowHold[ind].bottom = dragItem.style.bottom;
  2093.     bonkHUD.windowHold[ind].right = dragItem.style.right;
  2094.     bonkHUD.saveUISetting(ind);
  2095. };
  2096. // !Right now only useful for mods that have a setting that **only**
  2097. // !needs to be read from 
  2098.  
  2099. bonkHUD.saveModSetting = function (ind, obj) {
  2100.     let save_id = 'bonkHUD_Mod_Setting_' + bonkHUD.settingsHold[ind];
  2101.     localStorage.setItem(save_id, JSON.stringify(obj));
  2102. };
  2103.  
  2104. bonkHUD.getModSetting = function (ind) {
  2105.     let save_id = 'bonkHUD_Mod_Setting_' + bonkHUD.settingsHold[ind];
  2106.     let setting = JSON.parse(localStorage.getItem(save_id));
  2107.     if (!setting) {
  2108.         // !let mod maker handle it
  2109.         return null;
  2110.     }
  2111.     return setting;
  2112. };
  2113.  
  2114. /*bonkHUD.loadModSetting = function (id) {
  2115.     let windowElement = document.getElementById(id + "-drag");
  2116.     if (windowElement) {
  2117.         Object.assign(windowElement.style, bonkHUD.getUISetting(id));
  2118.     } else {
  2119.         console.log(`bonkHUD.loadModSetting: Window element not found for id: ${id}. Please ensure the window has been created.`);
  2120.     }
  2121. };*/
  2122.  
  2123. bonkHUD.resetModSetting = function (ind) {
  2124.     try {
  2125.         let save_id = 'bonkHUD_Mod_Setting_' + bonkHUD.settingsHold[ind];
  2126.         localStorage.removeItem(save_id);
  2127.         //Object.assign(windowElement.style, bonkHUD.getUISetting(id));
  2128.     } catch(er) {
  2129.         console.log(`bonkHUD.resetModSetting: Settings for ${bonkHUD.settingsHold[ind]} were not found.`);
  2130.     }
  2131. };
  2132.  
  2133. bonkHUD.createSettingsControl = function (settingsElement, element) {
  2134.     element.appendChild(settingsElement)
  2135.     //bonkHUD.settingsHold[ind].settings.appendChild(settingsElement);
  2136. };
  2137. // Function to start resizing the UI
  2138. bonkHUD.startResizing = function (e, dragItem, dir, ind) {
  2139.     e.stopPropagation(); // Prevent triggering dragStart for dragItem
  2140.  
  2141.     let startX = e.clientX;
  2142.     let startY = e.clientY;
  2143.     let windowX = parseInt(window.getComputedStyle(dragItem).right, 10);
  2144.     let windowY = parseInt(window.getComputedStyle(dragItem).bottom, 10);
  2145.     let startWidth = parseInt(window.getComputedStyle(dragItem).width, 10);
  2146.     let startHeight = parseInt(window.getComputedStyle(dragItem).height, 10);
  2147.  
  2148.     function doResize(e) {
  2149.         bonkHUD.resizeMove(e, startX, startY, windowX, windowY, startWidth, startHeight, dragItem, dir);
  2150.     }
  2151.  
  2152.     function stopResizing() {
  2153.         bonkHUD.resizeEnd(doResize, dragItem, ind);
  2154.     }
  2155.  
  2156.     document.addEventListener('mousemove', doResize);
  2157.     document.addEventListener('mouseup', stopResizing, { once: true });
  2158. };
  2159.  
  2160. // Function to handle the resize event
  2161. bonkHUD.resizeMove = function (e, startX, startY, windowX, windowY, startWidth, startHeight, dragItem, dir) {
  2162.     let newWidth = 0;
  2163.     let newHeight = 0;
  2164.     if(dir == "nw") {
  2165.         newWidth = startWidth - (e.clientX - startX);
  2166.         newHeight = startHeight - (e.clientY - startY);
  2167.         dragItem.style.height = bonkHUD.pxTorem(Math.max(30, newHeight)) + 'rem';
  2168.         dragItem.style.width = bonkHUD.pxTorem(Math.max(154, newWidth)) + 'rem';
  2169.     } else if(dir == "sw") {
  2170.         newWidth = startWidth - (e.clientX - startX);
  2171.         newHeight = startHeight + (e.clientY - startY);
  2172.         dragItem.style.height = bonkHUD.pxTorem(Math.max(30, newHeight)) + 'rem';
  2173.         dragItem.style.bottom = bonkHUD.pxTorem(windowY - (newHeight < 30 ? 30 - startHeight : e.clientY - startY)) + 'rem';
  2174.         dragItem.style.width = bonkHUD.pxTorem(Math.max(154, newWidth)) + 'rem';
  2175.     } else if(dir == "ne") {
  2176.         newWidth = startWidth + (e.clientX - startX);
  2177.         newHeight = startHeight - (e.clientY - startY);
  2178.         dragItem.style.height = bonkHUD.pxTorem(Math.max(30, newHeight)) + 'rem';
  2179.         dragItem.style.width = bonkHUD.pxTorem(Math.max(154, newWidth)) + 'rem';
  2180.         dragItem.style.right = bonkHUD.pxTorem(windowX - (newWidth < 154 ? 154 - startWidth : e.clientX - startX)) + 'rem';
  2181.     } else {
  2182.         newWidth = startWidth + (e.clientX - startX);
  2183.         newHeight = startHeight + (e.clientY - startY);
  2184.         dragItem.style.height = bonkHUD.pxTorem(Math.max(30, newHeight)) + 'rem';
  2185.         dragItem.style.bottom = bonkHUD.pxTorem(windowY - (newHeight < 30 ? 30 - startHeight : e.clientY - startY)) + 'rem';
  2186.         dragItem.style.width = bonkHUD.pxTorem(Math.max(154, newWidth)) + 'rem';
  2187.         dragItem.style.right = bonkHUD.pxTorem(windowX - (newWidth < 154 ? 154 - startWidth : e.clientX - startX)) + 'rem';
  2188.     }
  2189. };
  2190.  
  2191. // Function to stop the resize event
  2192. bonkHUD.resizeEnd = function (resizeMoveFn, dragItem, ind) {
  2193.     document.removeEventListener('mousemove', resizeMoveFn);
  2194.     //let ind = bonkHUD.getWindowIndexByID(dragItem.id.substring(0, dragItem.id.length - 5));
  2195.     bonkHUD.windowHold[ind].width = dragItem.style.width;
  2196.     bonkHUD.windowHold[ind].height = dragItem.style.height;
  2197.     bonkHUD.windowHold[ind].bottom = dragItem.style.bottom;
  2198.     bonkHUD.windowHold[ind].right = dragItem.style.right;
  2199.     bonkHUD.saveUISetting(ind);
  2200. };
  2201. bonkHUD.saveStyleSettings = function () {
  2202.     localStorage.setItem('bonkHUD_Style_Settings', JSON.stringify(bonkHUD.styleHold));
  2203. };
  2204.  
  2205. bonkHUD.exportStyleSettings = function() {
  2206.     let exportStyleHold = [];
  2207.     for(let prop in bonkHUD.styleHold) {
  2208.         exportStyleHold.push(bonkHUD.styleHold[prop].color);
  2209.     }
  2210.     let out = JSON.stringify(exportStyleHold);
  2211.     let save = new File([out], "bonkHUDStyle-" + Date.now() + ".style", {type: 'text/plain',});
  2212.  
  2213.     let url = URL.createObjectURL(save);
  2214.     let link = document.createElement("a");
  2215.     link.href = url;
  2216.     link.download = save.name;
  2217.     document.body.appendChild(link);
  2218.     link.click();
  2219.  
  2220.     document.body.removeChild(link);
  2221.     window.URL.revokeObjectURL(url);
  2222. }
  2223.  
  2224. bonkHUD.importStyleSettings = function(event) {
  2225.     if(!event || !event.target || !event.target.files || event.target.files.length === 0) {
  2226.         return;
  2227.     }
  2228.     let fileReader = new FileReader();
  2229.     fileReader.addEventListener("load", (e) => {
  2230.         let tempStyleHold = {};
  2231.         try {
  2232.             let temp = JSON.parse(e.target.result);
  2233.             let i = 0;
  2234.             for(let prop in bonkHUD.styleHold) {
  2235.                 tempStyleHold[prop] = {};
  2236.                 tempStyleHold[prop].class = bonkHUD.styleHold[prop].class;
  2237.                 tempStyleHold[prop].css = bonkHUD.styleHold[prop].css;
  2238.                 if(typeof temp[i] == "string" && temp[i].charAt(0) === "#" && !isNaN(Number("0x" + temp[i].substring(1, 7)))) {
  2239.                     tempStyleHold[prop].color = temp[i];
  2240.                 } else {
  2241.                     throw new Error("Incorrect style input");
  2242.                 }
  2243.                 i++;
  2244.             }
  2245.             bonkHUD.loadStyleSettings(tempStyleHold);
  2246.             bonkHUD.updateStyleSettings();
  2247.             bonkHUD.saveStyleSettings();
  2248.         } catch (er) {
  2249.             alert(er);
  2250.         }
  2251.     }, false);
  2252.     //let file = event.target.files[0];
  2253.     fileReader.readAsText(event.target.files[0]);
  2254. }
  2255.  
  2256. bonkHUD.loadStyleSettings = function (settings) {
  2257.     if(!settings) {
  2258.         settings = JSON.parse(localStorage.getItem('bonkHUD_Style_Settings'));
  2259.     }
  2260.     if (settings) {
  2261.         bonkHUD.styleHold = {};
  2262.         for (let prop in settings) {
  2263.             bonkHUD.styleHold[prop] = settings[prop];
  2264.         }
  2265.     }
  2266.     else {
  2267.         bonkHUD.resetStyleSettings();
  2268.     }
  2269. };
  2270.  
  2271. bonkHUD.resetStyleSettings = function () {
  2272.     localStorage.removeItem('bonkHUD_Style_Settings');
  2273.     //Add bonkhud to key for class name
  2274.     bonkHUD.styleHold = {
  2275.         backgroundColor: {class:"bonkhud-background-color", css:"background-color", color:"#cfd8cd"},
  2276.         borderColor: {class:"bonkhud-border-color", css:"border-color", color:"#b4b8ae"},
  2277.         headerColor: {class:"bonkhud-header-color", css:"background-color", color:"#009688"},
  2278.         titleColor: {class:"bonkhud-title-color", css:"color", color:"#ffffff"},
  2279.         textColor: {class:"bonkhud-text-color", css:"color", color:"#000000"},
  2280.         secondaryTextColor: {class:"bonkhud-secondary-text-color", css:"color", color:"#505050"},
  2281.         buttonColor: {class:"bonkhud-button-color", css:"background-color", color:"#bcc4bb"},
  2282.         buttonColorHover: {class:"bonkhud-button-color-hover", css:"background-color", color:"#acb9ad"},
  2283.     };
  2284. };
  2285.  
  2286. bonkHUD.updateStyleSettings = function () {
  2287.     for(let prop in bonkHUD.styleHold) {
  2288.         try {
  2289.             let colorEdit = document.getElementById("bonkhud-" + prop + "-edit");
  2290.             colorEdit.value = bonkHUD.styleHold[prop].color;
  2291.         } catch (er) {
  2292.             console.log("Element bonkhud-" + prop + "-edit does not exist");
  2293.         }
  2294.  
  2295.         if(prop == "buttonColorHover")
  2296.             continue;
  2297.         else if(prop == "headerColor") {
  2298.             let elements = document.getElementsByClassName(bonkHUD.styleHold[prop].class);
  2299.             for (let j = 0; j < elements.length; j++) {
  2300.                 elements[j].style.setProperty(bonkHUD.styleHold[prop].css, bonkHUD.styleHold[prop].color, "important");
  2301.             }
  2302.             continue;
  2303.         }
  2304.         else {
  2305.             let elements = document.getElementsByClassName(bonkHUD.styleHold[prop].class);
  2306.             for (let j = 0; j < elements.length; j++) {
  2307.                 elements[j].style.setProperty(bonkHUD.styleHold[prop].css, bonkHUD.styleHold[prop].color);
  2308.             }
  2309.         }
  2310.     }
  2311. };
  2312. bonkHUD.saveUISetting = function (ind) {
  2313.     let save_id = 'bonkHUD_Setting_' + bonkHUD.windowHold[ind].id;
  2314.     localStorage.setItem(save_id, JSON.stringify(bonkHUD.windowHold[ind]));
  2315. };
  2316.  
  2317. bonkHUD.getUISetting = function (ind) {
  2318.     let save_id = 'bonkHUD_Setting_' + bonkHUD.windowHold[ind].id;
  2319.     let setting = JSON.parse(localStorage.getItem(save_id));
  2320.     if (!setting) {
  2321.         setting = {
  2322.             id: bonkHUD.windowHold[ind].id,
  2323.             width: "154px",
  2324.             height: "100px",
  2325.             bottom: "0rem",
  2326.             right: "0rem",
  2327.             opacity: "1",
  2328.             display: "block",
  2329.         }
  2330.     }
  2331.     return setting;
  2332. };
  2333.  
  2334. bonkHUD.loadUISetting = function (ind) {
  2335.     let windowElement = document.getElementById(bonkHUD.windowHold[ind].id + "-drag");
  2336.     if (windowElement) {
  2337.         Object.assign(windowElement.style, bonkHUD.getUISetting(ind));
  2338.     } else {
  2339.         console.log(`bonkHUD.loadUISetting: Window element not found for id: ${bonkHUD.windowHold[ind].id}. Please ensure the window has been created.`);
  2340.     }
  2341. };
  2342.  
  2343. bonkHUD.resetUISetting = function (ind) {
  2344.     let windowElement = document.getElementById(bonkHUD.windowHold[ind].id + "-drag");
  2345.     if (windowElement) {
  2346.         let save_id = 'bonkHUD_Setting_' + bonkHUD.windowHold[ind].id;
  2347.         localStorage.removeItem(save_id);
  2348.         Object.assign(windowElement.style, bonkHUD.getUISetting(ind));
  2349.     } else {
  2350.         console.log(`bonkHUD.resetUISetting: Window element not found for id: ${bonkHUD.windowHold[ind].id}. Please ensure the window has been created.`);
  2351.     }
  2352. };
  2353. //! Eventually change ID to Id
  2354. bonkHUD.getWindowIndexByID = function (id) {
  2355.     for (let i = 0; i < bonkHUD.windowHold.length; i++) {
  2356.         if (bonkHUD.windowHold[i].id == id) {
  2357.             return i;
  2358.         }
  2359.     }
  2360.     return -1;
  2361. };
  2362.  
  2363. bonkHUD.getWindowIdByIndex = function (ind) {
  2364.     return bonkHUD.windowHold[ind].id
  2365. }
  2366.  
  2367. bonkHUD.getElementByIndex = function (ind) {
  2368.     return document.getElementById(bonkHUD.windowHold[ind].id)
  2369. }
  2370.  
  2371. bonkHUD.clamp = function (val, min, max) {
  2372.     //? supposedly faster than Math.max/min
  2373.     if (val > min) {
  2374.         if (val < max) {
  2375.             return val;
  2376.         }
  2377.         else {
  2378.             return max;
  2379.         }
  2380.     }
  2381.     return min;
  2382. };
  2383.  
  2384. bonkHUD.pxTorem = function (px) {
  2385.     return px / parseFloat(getComputedStyle(document.documentElement).fontSize);
  2386. };
  2387.  
  2388. bonkHUD.remTopx = function (rem) {
  2389.     return rem * parseFloat(getComputedStyle(document.documentElement).fontSize);
  2390. };
  2391. bonkHUD.generateButton = function (name) {
  2392.     let newButton = document.createElement("div");
  2393.     newButton.classList.add("bonkhud-button-color");
  2394.     newButton.classList.add("bonkhud-text-color");
  2395.     newButton.style.cursor = "pointer";
  2396.     newButton.style.borderRadius = "3px";
  2397.     newButton.style.textAlign = "center";
  2398.     newButton.style.backgroundColor = bonkHUD.styleHold.buttonColor.color;
  2399.     newButton.innerText = name;
  2400.  
  2401.     newButton.addEventListener('mouseover', (e) => {
  2402.         e.target.style.backgroundColor = bonkHUD.styleHold.buttonColorHover.color;
  2403.     });
  2404.     newButton.addEventListener('mouseleave', (e) => {
  2405.         e.target.style.backgroundColor = bonkHUD.styleHold.buttonColor.color;
  2406.     });
  2407.     return newButton;
  2408. }
  2409.  
  2410. bonkHUD.generateSection = function () {
  2411.     let sliderRow = document.createElement("div");
  2412.     sliderRow.classList.add("bonkhud-settings-row");
  2413.     sliderRow.classList.add("bonkhud-border-color");
  2414.     return sliderRow;
  2415. }
  2416. bonkHUD.initialize = function () {
  2417.     //bonkHUD.stylesheet = document.createElement("style");
  2418.     let settingsMenu = document.createElement("div");
  2419.     settingsMenu.id = "bonkhud-settings";
  2420.     settingsMenu.classList.add("bonkhud-background-color");
  2421.     settingsMenu.classList.add("windowShadow");
  2422.     settingsMenu.style.position = "absolute";
  2423.     settingsMenu.style.top = "0";
  2424.     settingsMenu.style.left = "0";
  2425.     settingsMenu.style.right = "0";
  2426.     settingsMenu.style.bottom = "0";
  2427.     settingsMenu.style.width = "60%";//bonkHUD.pxTorem(450) + "rem";
  2428.     settingsMenu.style.height = "75%";//bonkHUD.pxTorem(385) + "rem";
  2429.     settingsMenu.style.fontFamily = "futurept_b1";
  2430.     settingsMenu.style.margin = "auto";
  2431.     settingsMenu.style.borderRadius = "8px";
  2432.     //settingsMenu.style.outline = "3000px solid rgba(0,0,0,0.30)";
  2433.     settingsMenu.style.pointerEvents = "auto";
  2434.     settingsMenu.style.zIndex = "9992";
  2435.     settingsMenu.style.visibility = "hidden";
  2436.  
  2437.     // Create the header
  2438.     let header = document.createElement("div");
  2439.     header.classList.add("newbonklobby_boxtop");
  2440.     header.classList.add("newbonklobby_boxtop_classic");
  2441.     header.classList.add("bonkhud-header-color");
  2442.  
  2443.     // Create the title span
  2444.     let title = document.createElement("span");
  2445.     title.classList.add("bonkhud-title-color");
  2446.     title.textContent = "BonkHUD Settings";
  2447.     title.style.flexGrow = "1";
  2448.     title.style.textAlign = "center";
  2449.  
  2450.     let closeButton = document.createElement("div");
  2451.     closeButton.classList.add("bonkhud-header-button");
  2452.     closeButton.classList.add("bonkhud-title-color");
  2453.     closeButton.innerText = "_"; // Use an appropriate icon or text
  2454.     closeButton.style.lineHeight = "9px";
  2455.     closeButton.style.right = "3px";
  2456.     closeButton.style.cursor = "pointer";
  2457.  
  2458.     let containerContainer = document.createElement("div");
  2459.     containerContainer.classList.add("bonkhud-text-color");
  2460.     containerContainer.style.overflowX = "hidden";
  2461.     containerContainer.style.overflowY = "hidden";
  2462.     containerContainer.style.display = "flex";
  2463.     containerContainer.style.width = "100%";
  2464.     containerContainer.style.height = "calc(100% - 32px)"; // Adjusted height for header
  2465.  
  2466.     let windowSettingsContainer = document.createElement("div");
  2467.     windowSettingsContainer.id = "bonkhud-window-settings-container";
  2468.     windowSettingsContainer.classList.add("bonkhud-border-color");
  2469.     windowSettingsContainer.classList.add("bonkhud-scrollbar-kit");
  2470.     windowSettingsContainer.classList.add("bonkhud-scrollbar-other");
  2471.     windowSettingsContainer.style.width = "35%";
  2472.     windowSettingsContainer.style.overflowY = "scroll";
  2473.     windowSettingsContainer.style.height = "100%";
  2474.     windowSettingsContainer.style.borderRight = "1px solid";
  2475.  
  2476.     let settingsContainer = document.createElement("div");
  2477.     settingsContainer.classList.add("bonkhud-scrollbar-kit");
  2478.     settingsContainer.classList.add("bonkhud-scrollbar-other");
  2479.     settingsContainer.id = "bonkhud-settings-container";
  2480.     settingsContainer.style.overflowY = "scroll";
  2481.     settingsContainer.style.width = "65%";
  2482.     settingsContainer.style.float = "right";
  2483.     settingsContainer.style.height = "100%";
  2484.  
  2485.     // Create holder for mainSettings and styleSettings
  2486.     let generalSettingsDiv = document.createElement("div");
  2487.  
  2488.     let mainSettingsDiv = document.createElement("div");
  2489.     mainSettingsDiv.classList.add("bonkhud-border-color")
  2490.     mainSettingsDiv.classList.add("bonkhud-settings-row");
  2491.  
  2492.     let mainSettingsHeading = document.createElement("div");
  2493.     mainSettingsHeading.classList.add("bonkhud-text-color");
  2494.     mainSettingsHeading.style.fontSize = "1.2rem";
  2495.     mainSettingsHeading.style.marginBottom = "5px";
  2496.     mainSettingsHeading.textContent = "Main Settings";
  2497.  
  2498.     let mainSettingsAdHideLabel = document.createElement("label");
  2499.     mainSettingsAdHideLabel.classList.add("bonkhud-text-color");
  2500.     mainSettingsAdHideLabel.classList.add("bonkhud-settings-label");
  2501.     mainSettingsAdHideLabel.style.marginRight = "5px";
  2502.     mainSettingsAdHideLabel.innerText = "Hide Ads";
  2503.  
  2504.     let mainSettingsAdHide = document.createElement("input");
  2505.     mainSettingsAdHide.type = "checkbox";
  2506.     mainSettingsAdHide.checked = false;
  2507.  
  2508.     let styleResetDiv = document.createElement("div");
  2509.     styleResetDiv.style.marginTop = "5px";
  2510.  
  2511.     let styleResetLabel = document.createElement("label");
  2512.     styleResetLabel.classList.add("bonkhud-text-color");
  2513.     styleResetLabel.classList.add("bonkhud-settings-label");
  2514.     styleResetLabel.style.marginRight = "5px";
  2515.     styleResetLabel.innerText = "Reset Style";
  2516.  
  2517.     let styleResetButton = bonkHUD.generateButton("Reset");
  2518.     styleResetButton.style.paddingLeft = "5px";
  2519.     styleResetButton.style.paddingRight = "5px";
  2520.     styleResetButton.style.display = "inline-block";
  2521.  
  2522.     let styleExportDiv = document.createElement("div");
  2523.     styleExportDiv.style.marginTop = "5px";
  2524.  
  2525.     let styleExportLabel = document.createElement("label");
  2526.     styleExportLabel.classList.add("bonkhud-text-color");
  2527.     styleExportLabel.classList.add("bonkhud-settings-label");
  2528.     styleExportLabel.style.marginRight = "5px";
  2529.     styleExportLabel.innerText = "Export Style";
  2530.  
  2531.     let styleExportButton = bonkHUD.generateButton("Export");
  2532.     styleExportButton.style.paddingLeft = "5px";
  2533.     styleExportButton.style.paddingRight = "5px";
  2534.     styleExportButton.style.display = "inline-block";
  2535.  
  2536.     let styleImportDiv = document.createElement("div");
  2537.     styleImportDiv.style.marginTop = "5px";
  2538.  
  2539.     let styleImportLabel = document.createElement("label");
  2540.     styleImportLabel.classList.add("bonkhud-text-color");
  2541.     styleImportLabel.classList.add("bonkhud-settings-label");
  2542.     styleImportLabel.style.marginRight = "5px";
  2543.     styleImportLabel.innerText = "Import Style";
  2544.  
  2545.     let styleImportButton = bonkHUD.generateButton("Import");
  2546.     styleImportButton.style.paddingLeft = "5px";
  2547.     styleImportButton.style.paddingRight = "5px";
  2548.     styleImportButton.style.display = "inline-block";
  2549.  
  2550.     let styleImportInput = document.createElement("input");
  2551.     styleImportInput.setAttribute("type", "file");
  2552.     styleImportInput.setAttribute("accept", ".style");
  2553.     styleImportInput.setAttribute("multiple", "");
  2554.     styleImportInput.setAttribute("onChange", "bonkHUD.importStyleSettings(event);this.value=null");
  2555.     styleImportInput.style.display = "none";
  2556.  
  2557.     let styleSettingsDiv = document.createElement("div");
  2558.     styleSettingsDiv.classList.add("bonkhud-border-color")
  2559.     styleSettingsDiv.classList.add("bonkhud-settings-row");
  2560.  
  2561.     let styleSettingsHeading = document.createElement("div");
  2562.     styleSettingsHeading.classList.add("bonkhud-text-color");
  2563.     styleSettingsHeading.style.fontSize = "1.2rem";
  2564.     styleSettingsHeading.style.marginBottom = "5px";
  2565.     styleSettingsHeading.textContent = "Style Settings";
  2566.  
  2567.     mainSettingsDiv.appendChild(mainSettingsHeading);
  2568.     mainSettingsDiv.appendChild(mainSettingsAdHideLabel);
  2569.     mainSettingsDiv.appendChild(mainSettingsAdHide);
  2570.  
  2571.     // Append children of style settings to rows
  2572.     styleResetDiv.appendChild(styleResetLabel);
  2573.     styleResetDiv.appendChild(styleResetButton);
  2574.     styleExportDiv.appendChild(styleExportLabel);
  2575.     styleExportDiv.appendChild(styleExportButton);
  2576.     styleImportDiv.appendChild(styleImportLabel);
  2577.     styleImportDiv.appendChild(styleImportButton);
  2578.     styleImportDiv.appendChild(styleImportInput);
  2579.  
  2580.     styleSettingsDiv.appendChild(styleSettingsHeading);
  2581.     styleSettingsDiv.appendChild(styleResetDiv);
  2582.     styleSettingsDiv.appendChild(styleExportDiv)
  2583.     styleSettingsDiv.appendChild(styleImportDiv);
  2584.  
  2585.     let holdLeft = document.createElement("div");
  2586.     holdLeft.style.display = "flex";
  2587.     holdLeft.style.alignContent = "center";
  2588.  
  2589.     let opacityLabel = document.createElement("label");
  2590.     opacityLabel.classList.add("bonkhud-settings-label");
  2591.     opacityLabel.textContent = "Opacity";
  2592.  
  2593.     let opacitySlider = document.createElement("input");
  2594.     opacitySlider.type = "range"; // Slider type for range selection
  2595.     opacitySlider.min = "0.1"; // Minimum opacity value
  2596.     opacitySlider.max = "1"; // Maximum opacity value (fully opaque)
  2597.     opacitySlider.step = "0.05"; // Incremental steps for opacity adjustment
  2598.     opacitySlider.value = "1"; // Default value set to fully opaque
  2599.     opacitySlider.style.minWidth = "20px";
  2600.     opacitySlider.style.flexGrow = "1"; // Width adjusted for the label
  2601.  
  2602.     holdLeft.appendChild(opacityLabel);
  2603.     holdLeft.appendChild(opacitySlider);
  2604.  
  2605.     styleSettingsDiv.appendChild(holdLeft);
  2606.  
  2607.     for (let prop in bonkHUD.styleHold) {
  2608.         let colorDiv = document.createElement("div");
  2609.         colorDiv.style.marginTop="5px";
  2610.  
  2611.         let colorLabel = document.createElement("label");
  2612.         colorLabel.classList.add("bonkhud-text-color");
  2613.         colorLabel.classList.add("bonkhud-settings-label");
  2614.         colorLabel.style.marginRight = "10px";
  2615.         colorLabel.innerText = bonkHUD.styleHold[prop].class;
  2616.  
  2617.         let colorEdit = document.createElement("input");
  2618.         colorEdit.setAttribute('type', 'color');
  2619.         colorEdit.id = "bonkhud-" + prop + "-edit";
  2620.         colorEdit.value = bonkHUD.styleHold[prop].color;
  2621.         colorEdit.style.display = "inline-block";
  2622.  
  2623.         colorDiv.appendChild(colorLabel);
  2624.         colorDiv.appendChild(colorEdit);
  2625.  
  2626.         styleSettingsDiv.appendChild(colorDiv);
  2627.         colorEdit.addEventListener('change', (e) => {
  2628.             bonkHUD.styleHold[prop].color = e.target.value;
  2629.             bonkHUD.saveStyleSettings();
  2630.             bonkHUD.updateStyleSettings();
  2631.         });
  2632.     }
  2633.  
  2634.     let topBarButtons = document.querySelectorAll("#pretty_top_bar > .niceborderleft");
  2635.     //Create element in top bar
  2636.     let topBarOption = document.createElement("div");
  2637.     topBarOption.style.width = "58px";
  2638.     topBarOption.style.height = "34px";
  2639.     topBarOption.style.backgroundRepeat = "no-repeat";
  2640.     topBarOption.style.backgroundPosition = "center";
  2641.     topBarOption.style.position = "absolute";
  2642.     topBarOption.style.right = topBarButtons.length * 58 + 1 + "px";
  2643.     topBarOption.style.top = "0";
  2644.     topBarOption.style.visibility = "visible";
  2645.     topBarOption.style.borderBottom = "2px solid transparent";
  2646.     topBarOption.style.lineHeight = "34px";
  2647.     topBarOption.style.textAlign = "center";
  2648.     topBarOption.style.fontFamily = "futurept_b1";
  2649.     topBarOption.style.color = "#ffffff";
  2650.     topBarOption.classList.add("niceborderleft");
  2651.     topBarOption.classList.add("pretty_top_button");
  2652.  
  2653.     let topBarIcon = document.createElement("span");
  2654.     topBarIcon.innerText = "HUD";
  2655.  
  2656.     // Append Header
  2657.     header.appendChild(title);
  2658.     header.appendChild(closeButton)
  2659.  
  2660.     // Append everything to main container (HUD window)
  2661.     containerContainer.appendChild(windowSettingsContainer);
  2662.     containerContainer.appendChild(settingsContainer);
  2663.  
  2664.     settingsMenu.appendChild(header);
  2665.     settingsMenu.appendChild(containerContainer);
  2666.     topBarOption.appendChild(topBarIcon);
  2667.  
  2668.     document.getElementById('prettymenu').appendChild(settingsMenu);
  2669.     //Place it before help button
  2670.     document.getElementById('pretty_top_bar').appendChild(topBarOption);
  2671.  
  2672.     // Add settings
  2673.     bonkHUD.createSettingsControl(mainSettingsDiv, generalSettingsDiv);
  2674.     bonkHUD.createSettingsControl(styleSettingsDiv, generalSettingsDiv);
  2675.     bonkHUD.createMenuHeader("General", generalSettingsDiv);
  2676.  
  2677.     let ind = bonkHUD.settingsHold.length;
  2678.     bonkHUD.settingsHold.push("bonkhud-main-mod-setting");
  2679.     let settings = { hideAds: false, opacity: "1"};
  2680.     let tempSettings = bonkHUD.getModSetting(ind);
  2681.     if (tempSettings != null) {
  2682.         settings = tempSettings;
  2683.         // Could bring into one function then call it
  2684.         mainSettingsAdHide.checked = settings.hideAds;
  2685.         let ad1 = window.top.document.getElementById('adboxverticalCurse');
  2686.         let ad2 = window.top.document.getElementById('adboxverticalleftCurse');
  2687.         if (settings.hideAds) {
  2688.             ad1.style.display = "none";
  2689.             ad2.style.display = "none";
  2690.         } else {
  2691.             ad1.style.display = "block";
  2692.             ad2.style.display = "block";
  2693.         }
  2694.  
  2695.         opacitySlider.value = settings.opacity;
  2696.         settingsMenu.style.opacity = settings.opacity;
  2697.     }
  2698.  
  2699.     opacitySlider.oninput = function () {
  2700.         settingsMenu.style.opacity = this.value;
  2701.         settings.opacity = this.value;
  2702.         bonkHUD.saveModSetting(ind, settings);
  2703.     };
  2704.  
  2705.     mainSettingsAdHide.oninput = function () {
  2706.         settings.hideAds = this.checked;
  2707.         let ad1 = window.top.document.getElementById('adboxverticalCurse');
  2708.         let ad2 = window.top.document.getElementById('adboxverticalleftCurse');
  2709.         if (settings.hideAds) {
  2710.             ad1.style.display = "none";
  2711.             ad2.style.display = "none";
  2712.         } else {
  2713.             ad1.style.display = "block";
  2714.             ad2.style.display = "block";
  2715.         }
  2716.         bonkHUD.saveModSetting(ind, settings);
  2717.     }
  2718.  
  2719.     // Make menu to control opacity + visibility visible
  2720.     closeButton.addEventListener('click', (e) => {
  2721.         settingsMenu.style.visibility = "hidden";
  2722.     })
  2723.     topBarOption.addEventListener('click', (e) => {
  2724.         if (settingsMenu.style.visibility == "hidden") {
  2725.             settingsMenu.style.visibility = "visible";
  2726.         }
  2727.         else {
  2728.             settingsMenu.style.visibility = "hidden";
  2729.         }
  2730.     });
  2731.     styleResetButton.addEventListener('click', (e) => {
  2732.         bonkHUD.resetStyleSettings();
  2733.         bonkHUD.updateStyleSettings();
  2734.     });
  2735.     styleExportButton.addEventListener('click', (e) => {
  2736.         bonkHUD.updateStyleSettings();
  2737.         bonkHUD.exportStyleSettings();
  2738.     });
  2739.     styleImportButton.addEventListener('click', (e) => {
  2740.         styleImportInput.click();
  2741.     });
  2742. };
  2743. bonkHUD.createMenuHeader = function (name, settingsContent, recVersion = -1) {
  2744.     // Create container for the opacity controls with initial styles
  2745.     let sliderRow = bonkHUD.generateSection();
  2746.  
  2747.     // Add a title to the slider row for visual clarity
  2748.     let sliderTitle = document.createElement("div");
  2749.     if (recVersion === -1) {
  2750.         sliderTitle.textContent = name;
  2751.     } else {
  2752.         sliderTitle.textContent = name + " ("+recVersion+")";
  2753.     }
  2754.     sliderTitle.style.marginBottom = "5px";
  2755.     sliderTitle.style.fontSize = "1.2rem"; // Text size for readability
  2756.     sliderTitle.style.fontWeight = "bold"; // Make the title text bold
  2757.     sliderRow.appendChild(sliderTitle); // Insert the title into the slider container
  2758.  
  2759.     //open settings in
  2760.     settingsContent.prepend(sliderRow.cloneNode(true));
  2761.     settingsContent.classList.add("bonkhud-mod-setting-menu");
  2762.     settingsContent.style.display = "none";
  2763.     document.getElementById("bonkhud-settings-container").appendChild(settingsContent);
  2764.  
  2765.     sliderRow.addEventListener("click", (e) => {
  2766.         let menus = document.getElementsByClassName("bonkhud-mod-setting-menu");
  2767.         // Could make this without for loop but would need to store last menu
  2768.         for (let i = 0; i < menus.length; i++) {
  2769.             menus[i].style.display = "none";
  2770.         }
  2771.         settingsContent.style.display = "block";
  2772.  
  2773.         let titles = document.getElementById("bonkhud-window-settings-container").children;
  2774.         for (let i = 0; i < titles.length; i++) {
  2775.             titles[i].children[0].style.color = bonkHUD.styleHold.textColor.color;
  2776.         }
  2777.         sliderTitle.style.color = bonkHUD.styleHold.secondaryTextColor.color;
  2778.     });
  2779.  
  2780.     document.getElementById("bonkhud-window-settings-container").appendChild(sliderRow);
  2781. }
  2782.  
  2783. bonkHUD.createWindowControl = function (ind, element) {
  2784.     let sliderRow = bonkHUD.generateSection();
  2785.  
  2786.     let holdLeft = document.createElement("div");
  2787.     holdLeft.style.display = "flex";
  2788.     holdLeft.style.alignContent = "center";
  2789.  
  2790.     // Create a label for the opacity slider for accessibility
  2791.     let opacityLabel = document.createElement("label");
  2792.     opacityLabel.classList.add("bonkhud-settings-label");
  2793.     opacityLabel.textContent = "Opacity";
  2794.     holdLeft.appendChild(opacityLabel); // Add the label to the slider container
  2795.  
  2796.     // Create the opacity slider input, configuring its range and appearance
  2797.     let opacitySlider = document.createElement("input");
  2798.     opacitySlider.type = "range"; // Slider type for range selection
  2799.     opacitySlider.min = "0.1"; // Minimum opacity value
  2800.     opacitySlider.max = "1"; // Maximum opacity value (fully opaque)
  2801.     opacitySlider.step = "0.05"; // Incremental steps for opacity adjustment
  2802.     opacitySlider.value = bonkHUD.windowHold[ind].opacity; // Default value set to fully opaque
  2803.     opacitySlider.style.minWidth = "20px";
  2804.     opacitySlider.style.flexGrow = "1"; // Width adjusted for the label
  2805.     opacitySlider.oninput = function () {
  2806.         let control = document.getElementById(bonkHUD.windowHold[ind].id + "-drag"); // Update the UI opacity in real-time;
  2807.         control.style.opacity = this.value;
  2808.         bonkHUD.windowHold[ind].opacity = control.style.opacity;
  2809.         bonkHUD.saveUISetting(ind);
  2810.     };
  2811.     holdLeft.appendChild(opacitySlider); // Place the slider into the slider container
  2812.  
  2813.     let holdRight = document.createElement("div");
  2814.     let visibilityLabel = document.createElement("label");
  2815.     visibilityLabel.classList.add("bonkhud-settings-label");
  2816.     visibilityLabel.textContent = "Visible";
  2817.     visibilityLabel.style.marginRight = "5px"; // Space between label and slider
  2818.     visibilityLabel.style.display = "inline-block"; // Allows margin-top adjustment
  2819.     visibilityLabel.style.verticalAlign = "middle";
  2820.     holdRight.appendChild(visibilityLabel);
  2821.  
  2822.     let visiblityCheck = document.createElement("input");
  2823.     visiblityCheck.id = bonkHUD.windowHold[ind].id + "-visibility-check";
  2824.     visiblityCheck.type = "checkbox"; // Slider type for range selection
  2825.     if (bonkHUD.windowHold[ind].display == "block") {
  2826.         visiblityCheck.checked = true;
  2827.     }
  2828.     else {
  2829.         visiblityCheck.checked = false;
  2830.     }
  2831.     visiblityCheck.style.display = "inline-block"; // Allows margin-top adjustment
  2832.     visiblityCheck.style.verticalAlign = "middle";
  2833.     visiblityCheck.oninput = function () {
  2834.         let control = document.getElementById(bonkHUD.windowHold[ind].id + "-drag"); // Update the UI opacity in real-time;
  2835.         control.style.display = this.checked ? "block" : "none";
  2836.         bonkHUD.windowHold[ind].display = control.style.display;
  2837.         bonkHUD.saveUISetting(ind);
  2838.     };
  2839.     holdRight.appendChild(visiblityCheck); // Place the slider into the slider container
  2840.  
  2841.     let windowResetButton = bonkHUD.generateButton("Reset");
  2842.     windowResetButton.style.paddingLeft = "5px";
  2843.     windowResetButton.style.paddingRight = "5px";
  2844.     windowResetButton.style.display = "inline-block";
  2845.     windowResetButton.addEventListener('click', (e) => {
  2846.         bonkHUD.resetUISetting(ind);
  2847.         bonkHUD.loadUISetting(ind);
  2848.     });
  2849.  
  2850.     sliderRow.appendChild(holdLeft);
  2851.     sliderRow.appendChild(holdRight);
  2852.     sliderRow.appendChild(windowResetButton);
  2853.  
  2854.     element.appendChild(sliderRow);
  2855.     //bonkHUD.settingsHold[ind].settings.appendChild(sliderRow);
  2856. };
  2857.  
  2858. bonkHUD.focusWindow = function (focusItem) {
  2859.     let elements = document.getElementsByClassName("bonkhud-window-container");
  2860.     focusItem.style.zIndex = "9991";
  2861.     for (let i = 0; i < elements.length; i++) {
  2862.         if (focusItem.id != elements[i].id) {
  2863.             elements[i].style.zIndex = "9990";
  2864.         }
  2865.     }
  2866. };
  2867.  
  2868. //!------------------Load Complete Detection------------------
  2869. bonkLIB.onLoaded = () => {
  2870. bonkAPI.originalDrawShape = window.PIXI.Graphics.prototype.drawShape;
  2871. bonkAPI.pixiCtx = new window.PIXI.Container();
  2872.  
  2873. // !Map Decoder
  2874. bonkAPI.LZString = window.LZString;
  2875. bonkAPI.PSON = window.dcodeIO.PSON;
  2876. bonkAPI.bytebuffer = window.dcodeIO.ByteBuffer;
  2877. bonkAPI.textdecoder = new window.TextDecoder();
  2878. bonkAPI.textencoder = new window.TextEncoder();
  2879. bonkAPI.ISpsonpair = new window.dcodeIO.PSON.StaticPair([
  2880.     "physics",
  2881.     "shapes",
  2882.     "fixtures",
  2883.     "bodies",
  2884.     "bro",
  2885.     "joints",
  2886.     "ppm",
  2887.     "lights",
  2888.     "spawns",
  2889.     "lasers",
  2890.     "capZones",
  2891.     "type",
  2892.     "w",
  2893.     "h",
  2894.     "c",
  2895.     "a",
  2896.     "v",
  2897.     "l",
  2898.     "s",
  2899.     "sh",
  2900.     "fr",
  2901.     "re",
  2902.     "de",
  2903.     "sn",
  2904.     "fc",
  2905.     "fm",
  2906.     "f",
  2907.     "d",
  2908.     "n",
  2909.     "bg",
  2910.     "lv",
  2911.     "av",
  2912.     "ld",
  2913.     "ad",
  2914.     "fr",
  2915.     "bu",
  2916.     "cf",
  2917.     "rv",
  2918.     "p",
  2919.     "d",
  2920.     "bf",
  2921.     "ba",
  2922.     "bb",
  2923.     "aa",
  2924.     "ab",
  2925.     "axa",
  2926.     "dr",
  2927.     "em",
  2928.     "mmt",
  2929.     "mms",
  2930.     "ms",
  2931.     "ut",
  2932.     "lt",
  2933.     "New body",
  2934.     "Box Shape",
  2935.     "Circle Shape",
  2936.     "Polygon Shape",
  2937.     "EdgeChain Shape",
  2938.     "priority",
  2939.     "Light",
  2940.     "Laser",
  2941.     "Cap Zone",
  2942.     "BG Shape",
  2943.     "Background Layer",
  2944.     "Rotate Joint",
  2945.     "Slider Joint",
  2946.     "Rod Joint",
  2947.     "Gear Joint",
  2948.     65535,
  2949.     16777215,
  2950. ]);
  2951.  
  2952.  
  2953. class bonkAPI_bytebuffer {
  2954.     constructor() {
  2955.         var g1d = [arguments];
  2956.         this.index = 0;
  2957.         this.buffer = new ArrayBuffer(100*1024);
  2958.         this.view = new DataView(this.buffer);
  2959.         this.implicitClassAliasArray = [];
  2960.         this.implicitStringArray = [];
  2961.         this.bodgeCaptureZoneDataIdentifierArray = [];
  2962.     }
  2963.  
  2964.     readByte() {
  2965.         var N0H = [arguments];
  2966.         N0H[4] = this.view.getUint8(this.index);
  2967.         this.index += 1;
  2968.         return N0H[4];
  2969.     }
  2970.     writeByte(z0w) {
  2971.         var v8$ = [arguments];
  2972.         this.view.setUint8(this.index, v8$[0][0]);
  2973.         this.index += 1;
  2974.     }
  2975.     readInt() {
  2976.         var A71 = [arguments];
  2977.         A71[6] = this.view.getInt32(this.index);
  2978.         this.index += 4;
  2979.         return A71[6];
  2980.     }
  2981.     writeInt(W6i) {
  2982.         var p5u = [arguments];
  2983.         this.view.setInt32(this.index, p5u[0][0]);
  2984.         this.index += 4;
  2985.     }
  2986.     readShort() {
  2987.         var R1R = [arguments];
  2988.         R1R[9] = this.view.getInt16(this.index);
  2989.         this.index += 2;
  2990.         return R1R[9];
  2991.     }
  2992.     writeShort(H8B) {
  2993.         var d_3 = [arguments];
  2994.         this.view.setInt16(this.index, d_3[0][0]);
  2995.         this.index += 2;
  2996.     }
  2997.     readUint() {
  2998.         var W2$ = [arguments];
  2999.         W2$[8] = this.view.getUint32(this.index);
  3000.         this.index += 4;
  3001.         return W2$[8];
  3002.     }
  3003.     writeUint(B2X) {
  3004.         var f8B = [arguments];
  3005.         this.view.setUint32(this.index, f8B[0][0]);
  3006.         this.index += 4;
  3007.     }
  3008.     readBoolean() {
  3009.         var h6P = [arguments];
  3010.         h6P[6] = this.readByte();
  3011.         return h6P[6] == 1;
  3012.     }
  3013.     writeBoolean(Y3I) {
  3014.         var l79 = [arguments];
  3015.         if (l79[0][0]) {
  3016.         this.writeByte(1);
  3017.         } else {
  3018.         this.writeByte(0);
  3019.         }
  3020.     }
  3021.     readDouble() {
  3022.         var V60 = [arguments];
  3023.         V60[4] = this.view.getFloat64(this.index);
  3024.         this.index += 8;
  3025.         return V60[4];
  3026.     }
  3027.     writeDouble(z4Z) {
  3028.         var O41 = [arguments];
  3029.         this.view.setFloat64(this.index, O41[0][0]);
  3030.         this.index += 8;
  3031.     }
  3032.     readFloat() {
  3033.         var I0l = [arguments];
  3034.         I0l[5] = this.view.getFloat32(this.index);
  3035.         this.index += 4;
  3036.         return I0l[5];
  3037.     }
  3038.     writeFloat(y4B) {
  3039.         var B0v = [arguments];
  3040.         this.view.setFloat32(this.index, B0v[0][0]);
  3041.         this.index += 4;
  3042.     }
  3043.     readUTF() {
  3044.         var d6I = [arguments];
  3045.         d6I[8] = this.readByte();
  3046.         d6I[7] = this.readByte();
  3047.         d6I[9] = d6I[8] * 256 + d6I[7];
  3048.         d6I[1] = new Uint8Array(d6I[9]);
  3049.         for (d6I[6] = 0; d6I[6] < d6I[9]; d6I[6]++) {
  3050.         d6I[1][d6I[6]] = this.readByte();
  3051.         }
  3052.         return bonkAPI.textdecoder.decode(d6I[1]);
  3053.     }
  3054.     writeUTF(L3Z) {
  3055.         var Z75 = [arguments];
  3056.         Z75[4] = bonkAPI.textencoder.encode(Z75[0][0]);
  3057.         Z75[3] = Z75[4].length;
  3058.         Z75[5] = Math.floor(Z75[3]/256);
  3059.         Z75[8] = Z75[3] % 256;
  3060.         this.writeByte(Z75[5]);
  3061.         this.writeByte(Z75[8]);
  3062.         Z75[7] = this;
  3063.         Z75[4].forEach(I_O);
  3064.         function I_O(s0Q, H4K, j$o) {
  3065.         var N0o = [arguments];
  3066.         Z75[7].writeByte(N0o[0][0]);
  3067.         }
  3068.     }
  3069.     toBase64() {
  3070.         var P4$ = [arguments];
  3071.         P4$[4] = "";
  3072.         P4$[9] = new Uint8Array(this.buffer);
  3073.         P4$[8] = this.index;
  3074.         for (P4$[7] = 0; P4$[7] < P4$[8]; P4$[7]++) {
  3075.         P4$[4] += String.fromCharCode(P4$[9][P4$[7]]);
  3076.         }
  3077.         return window.btoa(P4$[4]);
  3078.     }
  3079.     fromBase64(W69, A8Q) {
  3080.         var o0n = [arguments];
  3081.         o0n[8] = window.pako;
  3082.         o0n[6] = window.atob(o0n[0][0]);
  3083.         o0n[9] = o0n[6].length;
  3084.         o0n[4] = new Uint8Array(o0n[9]);
  3085.         for (o0n[1] = 0; o0n[1] < o0n[9]; o0n[1]++) {
  3086.         o0n[4][o0n[1]] = o0n[6].charCodeAt(o0n[1]);
  3087.         }
  3088.         if (o0n[0][1] === true) {
  3089.         o0n[5] = o0n[8].inflate(o0n[4]);
  3090.         o0n[4] = o0n[5];
  3091.         }
  3092.         this.buffer = o0n[4].buffer.slice(
  3093.         o0n[4].byteOffset,
  3094.         o0n[4].byteLength + o0n[4].byteOffset
  3095.         );
  3096.         this.view = new DataView(this.buffer);
  3097.         this.index = 0;
  3098.     }
  3099. }
  3100. bonkAPI.ISdecode = function (rawdata) {
  3101.     rawdata_caseflipped = "";
  3102.     for (i = 0; i < rawdata.length; i++) {
  3103.         if (i <= 100 && rawdata.charAt(i) === rawdata.charAt(i).toLowerCase()) {
  3104.             rawdata_caseflipped += rawdata.charAt(i).toUpperCase();
  3105.         } else if (i <= 100 && rawdata.charAt(i) === rawdata.charAt(i).toUpperCase()) {
  3106.             rawdata_caseflipped += rawdata.charAt(i).toLowerCase();
  3107.         } else {
  3108.             rawdata_caseflipped += rawdata.charAt(i);
  3109.         }
  3110.     }
  3111.  
  3112.     data_deLZd = bonkAPI.LZString.decompressFromEncodedURIComponent(rawdata_caseflipped);
  3113.     databuffer = bonkAPI.bytebuffer.fromBase64(data_deLZd);
  3114.     data = bonkAPI.ISpsonpair.decode(databuffer.buffer);
  3115.     return data;
  3116. };
  3117.  
  3118. bonkAPI.ISencode = function (obj) {
  3119.     data = bonkAPI.ISpsonpair.encode(obj);
  3120.     b64 = data.toBase64();
  3121.     lzd = bonkAPI.LZString.compressToEncodedURIComponent(b64);
  3122.  
  3123.     caseflipped = "";
  3124.     for (i = 0; i < lzd.length; i++) {
  3125.         if (i <= 100 && lzd.charAt(i) === lzd.charAt(i).toLowerCase()) {
  3126.             caseflipped += lzd.charAt(i).toUpperCase();
  3127.         } else if (i <= 100 && lzd.charAt(i) === lzd.charAt(i).toUpperCase()) {
  3128.             caseflipped += lzd.charAt(i).toLowerCase();
  3129.         } else {
  3130.             caseflipped += lzd.charAt(i);
  3131.         }
  3132.     }
  3133.  
  3134.     return caseflipped;
  3135. };
  3136.  
  3137. bonkAPI.decodeIS = function (x) {
  3138.     return bonkAPI.ISdecode(x);
  3139. };
  3140. bonkAPI.encodeIS = function (x) {
  3141.     return bonkAPI.ISencode(x);
  3142. };
  3143.  
  3144. bonkAPI.encodeMap = function (W2A) {
  3145.     var M3n = [arguments];
  3146.     M3n[1] = new bonkAPI_bytebuffer();
  3147.     M3n[9] = M3n[0][0].physics;
  3148.     M3n[0][0].v = 15;
  3149.     M3n[1].writeShort(M3n[0][0].v);
  3150.     M3n[1].writeBoolean(M3n[0][0].s.re);
  3151.     M3n[1].writeBoolean(M3n[0][0].s.nc);
  3152.     M3n[1].writeShort(M3n[0][0].s.pq);
  3153.     M3n[1].writeFloat(M3n[0][0].s.gd);
  3154.     M3n[1].writeBoolean(M3n[0][0].s.fl);
  3155.     M3n[1].writeUTF(M3n[0][0].m.rxn);
  3156.     M3n[1].writeUTF(M3n[0][0].m.rxa);
  3157.     M3n[1].writeUint(M3n[0][0].m.rxid);
  3158.     M3n[1].writeShort(M3n[0][0].m.rxdb);
  3159.     M3n[1].writeUTF(M3n[0][0].m.n);
  3160.     M3n[1].writeUTF(M3n[0][0].m.a);
  3161.     M3n[1].writeUint(M3n[0][0].m.vu);
  3162.     M3n[1].writeUint(M3n[0][0].m.vd);
  3163.     M3n[1].writeShort(M3n[0][0].m.cr.length);
  3164.     for (M3n[84] = 0; M3n[84] < M3n[0][0].m.cr.length; M3n[84]++) {
  3165.         M3n[1].writeUTF(M3n[0][0].m.cr[M3n[84]]);
  3166.     }
  3167.     M3n[1].writeUTF(M3n[0][0].m.mo);
  3168.     M3n[1].writeInt(M3n[0][0].m.dbid);
  3169.     M3n[1].writeBoolean(M3n[0][0].m.pub);
  3170.     M3n[1].writeInt(M3n[0][0].m.dbv);
  3171.     M3n[1].writeShort(M3n[9].ppm);
  3172.     M3n[1].writeShort(M3n[9].bro.length);
  3173.     for (M3n[17] = 0; M3n[17] < M3n[9].bro.length; M3n[17]++) {
  3174.         M3n[1].writeShort(M3n[9].bro[M3n[17]]);
  3175.     }
  3176.     M3n[1].writeShort(M3n[9].shapes.length);
  3177.     for (M3n[80] = 0; M3n[80] < M3n[9].shapes.length; M3n[80]++) {
  3178.         M3n[2] = M3n[9].shapes[M3n[80]];
  3179.         if (M3n[2].type == "bx") {
  3180.             M3n[1].writeShort(1);
  3181.             M3n[1].writeDouble(M3n[2].w);
  3182.             M3n[1].writeDouble(M3n[2].h);
  3183.             M3n[1].writeDouble(M3n[2].c[0]);
  3184.             M3n[1].writeDouble(M3n[2].c[1]);
  3185.             M3n[1].writeDouble(M3n[2].a);
  3186.             M3n[1].writeBoolean(M3n[2].sk);
  3187.         }
  3188.         if (M3n[2].type == "ci") {
  3189.             M3n[1].writeShort(2);
  3190.             M3n[1].writeDouble(M3n[2].r);
  3191.             M3n[1].writeDouble(M3n[2].c[0]);
  3192.             M3n[1].writeDouble(M3n[2].c[1]);
  3193.             M3n[1].writeBoolean(M3n[2].sk);
  3194.         }
  3195.         if (M3n[2].type == "po") {
  3196.             M3n[1].writeShort(3);
  3197.             M3n[1].writeDouble(M3n[2].s);
  3198.             M3n[1].writeDouble(M3n[2].a);
  3199.             M3n[1].writeDouble(M3n[2].c[0]);
  3200.             M3n[1].writeDouble(M3n[2].c[1]);
  3201.             M3n[1].writeShort(M3n[2].v.length);
  3202.             for (M3n[61] = 0; M3n[61] < M3n[2].v.length; M3n[61]++) {
  3203.                 M3n[1].writeDouble(M3n[2].v[M3n[61]][0]);
  3204.                 M3n[1].writeDouble(M3n[2].v[M3n[61]][1]);
  3205.             }
  3206.         }
  3207.     }
  3208.     M3n[1].writeShort(M3n[9].fixtures.length);
  3209.     for (M3n[20] = 0; M3n[20] < M3n[9].fixtures.length; M3n[20]++) {
  3210.         M3n[7] = M3n[9].fixtures[M3n[20]];
  3211.         M3n[1].writeShort(M3n[7].sh);
  3212.         M3n[1].writeUTF(M3n[7].n);
  3213.         if (M3n[7].fr === null) {
  3214.             M3n[1].writeDouble(Number.MAX_VALUE);
  3215.         } else {
  3216.             M3n[1].writeDouble(M3n[7].fr);
  3217.         }
  3218.         if (M3n[7].fp === null) {
  3219.             M3n[1].writeShort(0);
  3220.         }
  3221.         if (M3n[7].fp === false) {
  3222.             M3n[1].writeShort(1);
  3223.         }
  3224.         if (M3n[7].fp === true) {
  3225.             M3n[1].writeShort(2);
  3226.         }
  3227.         if (M3n[7].re === null) {
  3228.             M3n[1].writeDouble(Number.MAX_VALUE);
  3229.         } else {
  3230.             M3n[1].writeDouble(M3n[7].re);
  3231.         }
  3232.         if (M3n[7].de === null) {
  3233.             M3n[1].writeDouble(Number.MAX_VALUE);
  3234.         } else {
  3235.             M3n[1].writeDouble(M3n[7].de);
  3236.         }
  3237.         M3n[1].writeUint(M3n[7].f);
  3238.         M3n[1].writeBoolean(M3n[7].d);
  3239.         M3n[1].writeBoolean(M3n[7].np);
  3240.         M3n[1].writeBoolean(M3n[7].ng);
  3241.         M3n[1].writeBoolean(M3n[7].ig);
  3242.     }
  3243.     M3n[1].writeShort(M3n[9].bodies.length);
  3244.     for (M3n[37] = 0; M3n[37] < M3n[9].bodies.length; M3n[37]++) {
  3245.         M3n[4] = M3n[9].bodies[M3n[37]];
  3246.         M3n[1].writeUTF(M3n[4].type);
  3247.         M3n[1].writeUTF(M3n[4].n);
  3248.         M3n[1].writeDouble(M3n[4].p[0]);
  3249.         M3n[1].writeDouble(M3n[4].p[1]);
  3250.         M3n[1].writeDouble(M3n[4].a);
  3251.         M3n[1].writeDouble(M3n[4].fric);
  3252.         M3n[1].writeBoolean(M3n[4].fricp);
  3253.         M3n[1].writeDouble(M3n[4].re);
  3254.         M3n[1].writeDouble(M3n[4].de);
  3255.         M3n[1].writeDouble(M3n[4].lv[0]);
  3256.         M3n[1].writeDouble(M3n[4].lv[1]);
  3257.         M3n[1].writeDouble(M3n[4].av);
  3258.         M3n[1].writeDouble(M3n[4].ld);
  3259.         M3n[1].writeDouble(M3n[4].ad);
  3260.         M3n[1].writeBoolean(M3n[4].fr);
  3261.         M3n[1].writeBoolean(M3n[4].bu);
  3262.         M3n[1].writeDouble(M3n[4].cf.x);
  3263.         M3n[1].writeDouble(M3n[4].cf.y);
  3264.         M3n[1].writeDouble(M3n[4].cf.ct);
  3265.         M3n[1].writeBoolean(M3n[4].cf.w);
  3266.         M3n[1].writeShort(M3n[4].f_c);
  3267.         M3n[1].writeBoolean(M3n[4].f_1);
  3268.         M3n[1].writeBoolean(M3n[4].f_2);
  3269.         M3n[1].writeBoolean(M3n[4].f_3);
  3270.         M3n[1].writeBoolean(M3n[4].f_4);
  3271.         M3n[1].writeBoolean(M3n[4].f_p);
  3272.         M3n[1].writeBoolean(M3n[4].fz.on);
  3273.         if (M3n[4].fz.on) {
  3274.             M3n[1].writeDouble(M3n[4].fz.x);
  3275.             M3n[1].writeDouble(M3n[4].fz.y);
  3276.             M3n[1].writeBoolean(M3n[4].fz.d);
  3277.             M3n[1].writeBoolean(M3n[4].fz.p);
  3278.             M3n[1].writeBoolean(M3n[4].fz.a);
  3279.             M3n[1].writeShort(M3n[4].fz.t);
  3280.             +M3n[1].writeDouble(M3n[4].fz.cf);
  3281.         }
  3282.         M3n[1].writeShort(M3n[4].fx.length);
  3283.         for (M3n[28] = 0; M3n[28] < M3n[4].fx.length; M3n[28]++) {
  3284.             M3n[1].writeShort(M3n[4].fx[M3n[28]]);
  3285.         }
  3286.     }
  3287.     M3n[1].writeShort(M3n[0][0].spawns.length);
  3288.     for (M3n[30] = 0; M3n[30] < M3n[0][0].spawns.length; M3n[30]++) {
  3289.         M3n[6] = M3n[0][0].spawns[M3n[30]];
  3290.         M3n[1].writeDouble(M3n[6].x);
  3291.         M3n[1].writeDouble(M3n[6].y);
  3292.         M3n[1].writeDouble(M3n[6].xv);
  3293.         M3n[1].writeDouble(M3n[6].yv);
  3294.         M3n[1].writeShort(M3n[6].priority);
  3295.         M3n[1].writeBoolean(M3n[6].r);
  3296.         M3n[1].writeBoolean(M3n[6].f);
  3297.         M3n[1].writeBoolean(M3n[6].b);
  3298.         M3n[1].writeBoolean(M3n[6].gr);
  3299.         M3n[1].writeBoolean(M3n[6].ye);
  3300.         M3n[1].writeUTF(M3n[6].n);
  3301.     }
  3302.     M3n[1].writeShort(M3n[0][0].capZones.length);
  3303.     for (M3n[74] = 0; M3n[74] < M3n[0][0].capZones.length; M3n[74]++) {
  3304.         M3n[3] = M3n[0][0].capZones[M3n[74]];
  3305.         M3n[1].writeUTF(M3n[3].n);
  3306.         M3n[1].writeDouble(M3n[3].l);
  3307.         M3n[1].writeShort(M3n[3].i);
  3308.         M3n[1].writeShort(M3n[3].ty);
  3309.     }
  3310.     M3n[1].writeShort(M3n[9].joints.length);
  3311.     for (M3n[89] = 0; M3n[89] < M3n[9].joints.length; M3n[89]++) {
  3312.         M3n[5] = M3n[9].joints[M3n[89]];
  3313.         if (M3n[5].type == "rv") {
  3314.             M3n[1].writeShort(1);
  3315.             M3n[1].writeDouble(M3n[5].d.la);
  3316.             M3n[1].writeDouble(M3n[5].d.ua);
  3317.             M3n[1].writeDouble(M3n[5].d.mmt);
  3318.             M3n[1].writeDouble(M3n[5].d.ms);
  3319.             M3n[1].writeBoolean(M3n[5].d.el);
  3320.             M3n[1].writeBoolean(M3n[5].d.em);
  3321.             M3n[1].writeDouble(M3n[5].aa[0]);
  3322.             M3n[1].writeDouble(M3n[5].aa[1]);
  3323.         }
  3324.         if (M3n[5].type == "d") {
  3325.             M3n[1].writeShort(2);
  3326.             M3n[1].writeDouble(M3n[5].d.fh);
  3327.             M3n[1].writeDouble(M3n[5].d.dr);
  3328.             M3n[1].writeDouble(M3n[5].aa[0]);
  3329.             M3n[1].writeDouble(M3n[5].aa[1]);
  3330.             M3n[1].writeDouble(M3n[5].ab[0]);
  3331.             M3n[1].writeDouble(M3n[5].ab[1]);
  3332.         }
  3333.         if (M3n[5].type == "lpj") {
  3334.             M3n[1].writeShort(3);
  3335.             M3n[1].writeDouble(M3n[5].pax);
  3336.             M3n[1].writeDouble(M3n[5].pay);
  3337.             M3n[1].writeDouble(M3n[5].pa);
  3338.             M3n[1].writeDouble(M3n[5].pf);
  3339.             M3n[1].writeDouble(M3n[5].pl);
  3340.             M3n[1].writeDouble(M3n[5].pu);
  3341.             M3n[1].writeDouble(M3n[5].plen);
  3342.             M3n[1].writeDouble(M3n[5].pms);
  3343.         }
  3344.         if (M3n[5].type == "lsj") {
  3345.             M3n[1].writeShort(4);
  3346.             M3n[1].writeDouble(M3n[5].sax);
  3347.             M3n[1].writeDouble(M3n[5].say);
  3348.             M3n[1].writeDouble(M3n[5].sf);
  3349.             M3n[1].writeDouble(M3n[5].slen);
  3350.         }
  3351.         if (M3n[5].type == "g") {
  3352.             M3n[1].writeShort(5);
  3353.             M3n[1].writeUTF(M3n[5].n);
  3354.             M3n[1].writeShort(M3n[5].ja);
  3355.             M3n[1].writeShort(M3n[5].jb);
  3356.             M3n[1].writeDouble(M3n[5].r);
  3357.         }
  3358.         if (M3n[5].type != "g") {
  3359.             M3n[1].writeShort(M3n[5].ba);
  3360.             M3n[1].writeShort(M3n[5].bb);
  3361.             M3n[1].writeBoolean(M3n[5].d.cc);
  3362.             M3n[1].writeDouble(M3n[5].d.bf);
  3363.             M3n[1].writeBoolean(M3n[5].d.dl);
  3364.         }
  3365.     }
  3366.     M3n[32] = M3n[1].toBase64();
  3367.     M3n[77] = LZString.compressToEncodedURIComponent(M3n[32]);
  3368.     return M3n[77];
  3369. };
  3370.  
  3371. bonkAPI.decodeMap = function (map) {
  3372.     var F5W = [arguments];
  3373.     var b64mapdata = LZString.decompressFromEncodedURIComponent(map);
  3374.     var binaryReader = new bonkAPI_bytebuffer();
  3375.     binaryReader.fromBase64(b64mapdata, false);
  3376.     map = {
  3377.         v: 1,
  3378.         s: { re: false, nc: false, pq: 1, gd: 25, fl: false },
  3379.         physics: { shapes: [], fixtures: [], bodies: [], bro: [], joints: [], ppm: 12 },
  3380.         spawns: [],
  3381.         capZones: [],
  3382.         m: {
  3383.             a: "noauthor",
  3384.             n: "noname",
  3385.             dbv: 2,
  3386.             dbid: -1,
  3387.             authid: -1,
  3388.             date: "",
  3389.             rxid: 0,
  3390.             rxn: "",
  3391.             rxa: "",
  3392.             rxdb: 1,
  3393.             cr: [],
  3394.             pub: false,
  3395.             mo: "",
  3396.         },
  3397.     };
  3398.     map.physics = map.physics;
  3399.     map.v = binaryReader.readShort();
  3400.     if (map.v > 15) {
  3401.         throw new Error("Future map version, please refresh page");
  3402.     }
  3403.     map.s.re = binaryReader.readBoolean();
  3404.     map.s.nc = binaryReader.readBoolean();
  3405.     if (map.v >= 3) {
  3406.         map.s.pq = binaryReader.readShort();
  3407.     }
  3408.     if (map.v >= 4 && map.v <= 12) {
  3409.         map.s.gd = binaryReader.readShort();
  3410.     } else if (map.v >= 13) {
  3411.         map.s.gd = binaryReader.readFloat();
  3412.     }
  3413.     if (map.v >= 9) {
  3414.         map.s.fl = binaryReader.readBoolean();
  3415.     }
  3416.     map.m.rxn = binaryReader.readUTF();
  3417.     map.m.rxa = binaryReader.readUTF();
  3418.     map.m.rxid = binaryReader.readUint();
  3419.     map.m.rxdb = binaryReader.readShort();
  3420.     map.m.n = binaryReader.readUTF();
  3421.     map.m.a = binaryReader.readUTF();
  3422.     if (map.v >= 10) {
  3423.         map.m.vu = binaryReader.readUint();
  3424.         map.m.vd = binaryReader.readUint();
  3425.     }
  3426.     if (map.v >= 4) {
  3427.         F5W[7] = binaryReader.readShort();
  3428.         for (F5W[83] = 0; F5W[83] < F5W[7]; F5W[83]++) {
  3429.             map.m.cr.push(binaryReader.readUTF());
  3430.         }
  3431.     }
  3432.     if (map.v >= 5) {
  3433.         map.m.mo = binaryReader.readUTF();
  3434.         map.m.dbid = binaryReader.readInt();
  3435.     }
  3436.     if (map.v >= 7) {
  3437.         map.m.pub = binaryReader.readBoolean();
  3438.     }
  3439.     if (map.v >= 8) {
  3440.         map.m.dbv = binaryReader.readInt();
  3441.     }
  3442.     map.physics.ppm = binaryReader.readShort();
  3443.     F5W[4] = binaryReader.readShort();
  3444.     for (F5W[15] = 0; F5W[15] < F5W[4]; F5W[15]++) {
  3445.         map.physics.bro[F5W[15]] = binaryReader.readShort();
  3446.     }
  3447.     F5W[6] = binaryReader.readShort();
  3448.     for (F5W[28] = 0; F5W[28] < F5W[6]; F5W[28]++) {
  3449.         F5W[5] = binaryReader.readShort();
  3450.         if (F5W[5] == 1) {
  3451.             map.physics.shapes[F5W[28]] = { type: "bx", w: 10, h: 40, c: [0, 0], a: 0.0, sk: false };
  3452.             map.physics.shapes[F5W[28]].w = binaryReader.readDouble();
  3453.             map.physics.shapes[F5W[28]].h = binaryReader.readDouble();
  3454.             map.physics.shapes[F5W[28]].c = [binaryReader.readDouble(), binaryReader.readDouble()];
  3455.             map.physics.shapes[F5W[28]].a = binaryReader.readDouble();
  3456.             map.physics.shapes[F5W[28]].sk = binaryReader.readBoolean();
  3457.         }
  3458.         if (F5W[5] == 2) {
  3459.             map.physics.shapes[F5W[28]] = { type: "ci", r: 25, c: [0, 0], sk: false };
  3460.             map.physics.shapes[F5W[28]].r = binaryReader.readDouble();
  3461.             map.physics.shapes[F5W[28]].c = [binaryReader.readDouble(), binaryReader.readDouble()];
  3462.             map.physics.shapes[F5W[28]].sk = binaryReader.readBoolean();
  3463.         }
  3464.         if (F5W[5] == 3) {
  3465.             map.physics.shapes[F5W[28]] = { type: "po", v: [], s: 1, a: 0, c: [0, 0] };
  3466.             map.physics.shapes[F5W[28]].s = binaryReader.readDouble();
  3467.             map.physics.shapes[F5W[28]].a = binaryReader.readDouble();
  3468.             map.physics.shapes[F5W[28]].c = [binaryReader.readDouble(), binaryReader.readDouble()];
  3469.             F5W[74] = binaryReader.readShort();
  3470.             map.physics.shapes[F5W[28]].v = [];
  3471.             for (F5W[27] = 0; F5W[27] < F5W[74]; F5W[27]++) {
  3472.                 map.physics.shapes[F5W[28]].v.push([
  3473.                     binaryReader.readDouble(),
  3474.                     binaryReader.readDouble(),
  3475.                 ]);
  3476.             }
  3477.         }
  3478.     }
  3479.     F5W[71] = binaryReader.readShort();
  3480.     for (F5W[17] = 0; F5W[17] < F5W[71]; F5W[17]++) {
  3481.         map.physics.fixtures[F5W[17]] = {
  3482.             sh: 0,
  3483.             n: "Def Fix",
  3484.             fr: 0.3,
  3485.             fp: null,
  3486.             re: 0.8,
  3487.             de: 0.3,
  3488.             f: 0x4f7cac,
  3489.             d: false,
  3490.             np: false,
  3491.             ng: false,
  3492.         };
  3493.         map.physics.fixtures[F5W[17]].sh = binaryReader.readShort();
  3494.         map.physics.fixtures[F5W[17]].n = binaryReader.readUTF();
  3495.         map.physics.fixtures[F5W[17]].fr = binaryReader.readDouble();
  3496.         if (map.physics.fixtures[F5W[17]].fr == Number.MAX_VALUE) {
  3497.             map.physics.fixtures[F5W[17]].fr = null;
  3498.         }
  3499.         F5W[12] = binaryReader.readShort();
  3500.         if (F5W[12] == 0) {
  3501.             map.physics.fixtures[F5W[17]].fp = null;
  3502.         }
  3503.         if (F5W[12] == 1) {
  3504.             map.physics.fixtures[F5W[17]].fp = false;
  3505.         }
  3506.         if (F5W[12] == 2) {
  3507.             map.physics.fixtures[F5W[17]].fp = true;
  3508.         }
  3509.         map.physics.fixtures[F5W[17]].re = binaryReader.readDouble();
  3510.         if (map.physics.fixtures[F5W[17]].re == Number.MAX_VALUE) {
  3511.             map.physics.fixtures[F5W[17]].re = null;
  3512.         }
  3513.         map.physics.fixtures[F5W[17]].de = binaryReader.readDouble();
  3514.         if (map.physics.fixtures[F5W[17]].de == Number.MAX_VALUE) {
  3515.             map.physics.fixtures[F5W[17]].de = null;
  3516.         }
  3517.         map.physics.fixtures[F5W[17]].f = binaryReader.readUint();
  3518.         map.physics.fixtures[F5W[17]].d = binaryReader.readBoolean();
  3519.         map.physics.fixtures[F5W[17]].np = binaryReader.readBoolean();
  3520.         if (map.v >= 11) {
  3521.             map.physics.fixtures[F5W[17]].ng = binaryReader.readBoolean();
  3522.         }
  3523.         if (map.v >= 12) {
  3524.             map.physics.fixtures[F5W[17]].ig = binaryReader.readBoolean();
  3525.         }
  3526.     }
  3527.     F5W[63] = binaryReader.readShort();
  3528.     for (F5W[52] = 0; F5W[52] < F5W[63]; F5W[52]++) {
  3529.         map.physics.bodies[F5W[52]] = {
  3530.             type: "s",
  3531.             n: "Unnamed",
  3532.             p: [0, 0],
  3533.             a: 0,
  3534.             fric: 0.3,
  3535.             fricp: false,
  3536.             re: 0.8,
  3537.             de: 0.3,
  3538.             lv: [0, 0],
  3539.             av: 0,
  3540.             ld: 0,
  3541.             ad: 0,
  3542.             fr: false,
  3543.             bu: false,
  3544.             cf: { x: 0, y: 0, w: true, ct: 0 },
  3545.             fx: [],
  3546.             f_c: 1,
  3547.             f_p: true,
  3548.             f_1: true,
  3549.             f_2: true,
  3550.             f_3: true,
  3551.             f_4: true,
  3552.             fz: { on: false, x: 0, y: 0, d: true, p: true, a: true, t: 0, cf: 0 },
  3553.         };
  3554.         map.physics.bodies[F5W[52]].type = binaryReader.readUTF();
  3555.         map.physics.bodies[F5W[52]].n = binaryReader.readUTF();
  3556.         map.physics.bodies[F5W[52]].p = [binaryReader.readDouble(), binaryReader.readDouble()];
  3557.         map.physics.bodies[F5W[52]].a = binaryReader.readDouble();
  3558.         map.physics.bodies[F5W[52]].fric = binaryReader.readDouble();
  3559.         map.physics.bodies[F5W[52]].fricp = binaryReader.readBoolean();
  3560.         map.physics.bodies[F5W[52]].re = binaryReader.readDouble();
  3561.         map.physics.bodies[F5W[52]].de = binaryReader.readDouble();
  3562.         map.physics.bodies[F5W[52]].lv = [binaryReader.readDouble(), binaryReader.readDouble()];
  3563.         map.physics.bodies[F5W[52]].av = binaryReader.readDouble();
  3564.         map.physics.bodies[F5W[52]].ld = binaryReader.readDouble();
  3565.         map.physics.bodies[F5W[52]].ad = binaryReader.readDouble();
  3566.         map.physics.bodies[F5W[52]].fr = binaryReader.readBoolean();
  3567.         map.physics.bodies[F5W[52]].bu = binaryReader.readBoolean();
  3568.         map.physics.bodies[F5W[52]].cf.x = binaryReader.readDouble();
  3569.         map.physics.bodies[F5W[52]].cf.y = binaryReader.readDouble();
  3570.         map.physics.bodies[F5W[52]].cf.ct = binaryReader.readDouble();
  3571.         map.physics.bodies[F5W[52]].cf.w = binaryReader.readBoolean();
  3572.         map.physics.bodies[F5W[52]].f_c = binaryReader.readShort();
  3573.         map.physics.bodies[F5W[52]].f_1 = binaryReader.readBoolean();
  3574.         map.physics.bodies[F5W[52]].f_2 = binaryReader.readBoolean();
  3575.         map.physics.bodies[F5W[52]].f_3 = binaryReader.readBoolean();
  3576.         map.physics.bodies[F5W[52]].f_4 = binaryReader.readBoolean();
  3577.         if (map.v >= 2) {
  3578.             map.physics.bodies[F5W[52]].f_p = binaryReader.readBoolean();
  3579.         }
  3580.         if (map.v >= 14) {
  3581.             map.physics.bodies[F5W[52]].fz.on = binaryReader.readBoolean();
  3582.             if (map.physics.bodies[F5W[52]].fz.on) {
  3583.                 map.physics.bodies[F5W[52]].fz.x = binaryReader.readDouble();
  3584.                 map.physics.bodies[F5W[52]].fz.y = binaryReader.readDouble();
  3585.                 map.physics.bodies[F5W[52]].fz.d = binaryReader.readBoolean();
  3586.                 map.physics.bodies[F5W[52]].fz.p = binaryReader.readBoolean();
  3587.                 map.physics.bodies[F5W[52]].fz.a = binaryReader.readBoolean();
  3588.                 if (map.v >= 15) {
  3589.                     map.physics.bodies[F5W[52]].t = binaryReader.readShort();
  3590.                     map.physics.bodies[F5W[52]].cf = binaryReader.readDouble();
  3591.                 }
  3592.             }
  3593.         }
  3594.         F5W[88] = binaryReader.readShort();
  3595.         for (F5W[65] = 0; F5W[65] < F5W[88]; F5W[65]++) {
  3596.             map.physics.bodies[F5W[52]].fx.push(binaryReader.readShort());
  3597.         }
  3598.     }
  3599.     F5W[97] = binaryReader.readShort();
  3600.     for (F5W[41] = 0; F5W[41] < F5W[97]; F5W[41]++) {
  3601.         map.spawns[F5W[41]] = {
  3602.             x: 400,
  3603.             y: 300,
  3604.             xv: 0,
  3605.             yv: 0,
  3606.             priority: 5,
  3607.             r: true,
  3608.             f: true,
  3609.             b: true,
  3610.             gr: false,
  3611.             ye: false,
  3612.             n: "Spawn",
  3613.         };
  3614.         F5W[35] = map.spawns[F5W[41]];
  3615.         F5W[35].x = binaryReader.readDouble();
  3616.         F5W[35].y = binaryReader.readDouble();
  3617.         F5W[35].xv = binaryReader.readDouble();
  3618.         F5W[35].yv = binaryReader.readDouble();
  3619.         F5W[35].priority = binaryReader.readShort();
  3620.         F5W[35].r = binaryReader.readBoolean();
  3621.         F5W[35].f = binaryReader.readBoolean();
  3622.         F5W[35].b = binaryReader.readBoolean();
  3623.         F5W[35].gr = binaryReader.readBoolean();
  3624.         F5W[35].ye = binaryReader.readBoolean();
  3625.         F5W[35].n = binaryReader.readUTF();
  3626.     }
  3627.     F5W[16] = binaryReader.readShort();
  3628.     for (F5W[25] = 0; F5W[25] < F5W[16]; F5W[25]++) {
  3629.         map.capZones[F5W[25]] = { n: "Cap Zone", ty: 1, l: 10, i: -1 };
  3630.         map.capZones[F5W[25]].n = binaryReader.readUTF();
  3631.         map.capZones[F5W[25]].l = binaryReader.readDouble();
  3632.         map.capZones[F5W[25]].i = binaryReader.readShort();
  3633.         if (map.v >= 6) {
  3634.             map.capZones[F5W[25]].ty = binaryReader.readShort();
  3635.         }
  3636.     }
  3637.     F5W[98] = binaryReader.readShort();
  3638.     for (F5W[19] = 0; F5W[19] < F5W[98]; F5W[19]++) {
  3639.         F5W[31] = binaryReader.readShort();
  3640.         if (F5W[31] == 1) {
  3641.             map.physics.joints[F5W[19]] = {
  3642.                 type: "rv",
  3643.                 d: { la: 0, ua: 0, mmt: 0, ms: 0, el: false, em: false, cc: false, bf: 0, dl: true },
  3644.                 aa: [0, 0],
  3645.             };
  3646.             F5W[20] = map.physics.joints[F5W[19]];
  3647.             F5W[20].d.la = binaryReader.readDouble();
  3648.             F5W[20].d.ua = binaryReader.readDouble();
  3649.             F5W[20].d.mmt = binaryReader.readDouble();
  3650.             F5W[20].d.ms = binaryReader.readDouble();
  3651.             F5W[20].d.el = binaryReader.readBoolean();
  3652.             F5W[20].d.em = binaryReader.readBoolean();
  3653.             F5W[20].aa = [binaryReader.readDouble(), binaryReader.readDouble()];
  3654.         }
  3655.         if (F5W[31] == 2) {
  3656.             map.physics.joints[F5W[19]] = {
  3657.                 type: "d",
  3658.                 d: { fh: 0, dr: 0, cc: false, bf: 0, dl: true },
  3659.                 aa: [0, 0],
  3660.                 ab: [0, 0],
  3661.             };
  3662.             F5W[87] = map.physics.joints[F5W[19]];
  3663.             F5W[87].d.fh = binaryReader.readDouble();
  3664.             F5W[87].d.dr = binaryReader.readDouble();
  3665.             F5W[87].aa = [binaryReader.readDouble(), binaryReader.readDouble()];
  3666.             F5W[87].ab = [binaryReader.readDouble(), binaryReader.readDouble()];
  3667.         }
  3668.         if (F5W[31] == 3) {
  3669.             map.physics.joints[F5W[19]] = {
  3670.                 type: "lpj",
  3671.                 d: { cc: false, bf: 0, dl: true },
  3672.                 pax: 0,
  3673.                 pay: 0,
  3674.                 pa: 0,
  3675.                 pf: 0,
  3676.                 pl: 0,
  3677.                 pu: 0,
  3678.                 plen: 0,
  3679.                 pms: 0,
  3680.             };
  3681.             F5W[90] = map.physics.joints[F5W[19]];
  3682.             F5W[90].pax = binaryReader.readDouble();
  3683.             F5W[90].pay = binaryReader.readDouble();
  3684.             F5W[90].pa = binaryReader.readDouble();
  3685.             F5W[90].pf = binaryReader.readDouble();
  3686.             F5W[90].pl = binaryReader.readDouble();
  3687.             F5W[90].pu = binaryReader.readDouble();
  3688.             F5W[90].plen = binaryReader.readDouble();
  3689.             F5W[90].pms = binaryReader.readDouble();
  3690.         }
  3691.         if (F5W[31] == 4) {
  3692.             map.physics.joints[F5W[19]] = {
  3693.                 type: "lsj",
  3694.                 d: { cc: false, bf: 0, dl: true },
  3695.                 sax: 0,
  3696.                 say: 0,
  3697.                 sf: 0,
  3698.                 slen: 0,
  3699.             };
  3700.             F5W[44] = map.physics.joints[F5W[19]];
  3701.             F5W[44].sax = binaryReader.readDouble();
  3702.             F5W[44].say = binaryReader.readDouble();
  3703.             F5W[44].sf = binaryReader.readDouble();
  3704.             F5W[44].slen = binaryReader.readDouble();
  3705.         }
  3706.         if (F5W[31] == 5) {
  3707.             map.physics.joints[F5W[19]] = { type: "g", n: "", ja: -1, jb: -1, r: 1 };
  3708.             F5W[91] = map.physics.joints[F5W[19]];
  3709.             F5W[91].n = binaryReader.readUTF();
  3710.             F5W[91].ja = binaryReader.readShort();
  3711.             F5W[91].jb = binaryReader.readShort();
  3712.             F5W[91].r = binaryReader.readDouble();
  3713.         }
  3714.         if (F5W[31] != 5) {
  3715.             map.physics.joints[F5W[19]].ba = binaryReader.readShort();
  3716.             map.physics.joints[F5W[19]].bb = binaryReader.readShort();
  3717.             map.physics.joints[F5W[19]].d.cc = binaryReader.readBoolean();
  3718.             map.physics.joints[F5W[19]].d.bf = binaryReader.readDouble();
  3719.             map.physics.joints[F5W[19]].d.dl = binaryReader.readBoolean();
  3720.         }
  3721.     }
  3722.     return map;
  3723. };
  3724. window.PIXI.Graphics.prototype.drawShape = function(...args) {
  3725.     //! testing whether cap can be easily found in drawShape
  3726.     //! in drawCircle, capzone has attribute 'cap: "bet"' inside fill_outline
  3727.     //console.log([...args]);
  3728.     let draw = this;
  3729.     setTimeout(function(){
  3730.         if(draw.parent) {
  3731.             bonkAPI.parentDraw = draw.parent;
  3732.             while(bonkAPI.parentDraw.parent != null) {
  3733.                 bonkAPI.parentDraw = bonkAPI.parentDraw.parent;
  3734.             }
  3735.         }
  3736.     }, 0);
  3737.     return bonkAPI.originalDrawShape.call(this, ...args);
  3738. }
  3739. window.requestAnimationFrame = function(...args) {
  3740.     //console.log(bonkAPI.isInGame());
  3741.     if(bonkAPI.isInGame()) {
  3742.         let canv = 0;
  3743.         for(let i = 0; i < document.getElementById("gamerenderer").children.length; i++) {
  3744.             if(document.getElementById("gamerenderer").children[i].constructor.name == "HTMLCanvasElement"){
  3745.                 canv = document.getElementById("gamerenderer").children[i];
  3746.                 break;
  3747.             }
  3748.         }
  3749.         //console.log(bonkAPI.parentDraw);
  3750.         if(canv != 0 && bonkAPI.parentDraw) {
  3751.             //! might do something might not
  3752.             while(bonkAPI.parentDraw.parent != null) {
  3753.                 bonkAPI.parentDraw = bonkAPI.parentDraw.parent;
  3754.             }
  3755.             /**
  3756.              * When a new frame is rendered when in game. It is recomended
  3757.              * to not create new graphics or clear graphics every frame if
  3758.              * possible.
  3759.              * @event graphicsUpdate
  3760.              * @type {object}
  3761.              * @property {string} container - PIXI container to hold PIXI graphics.
  3762.              * @property {number} width - Width of main screen
  3763.              * @property {number} height - Height of main screen
  3764.              */
  3765.             if(bonkAPI.events.hasEvent["graphicsUpdate"]) {
  3766.                 let w = parseInt(canv.style.width);
  3767.                 let h = parseInt(canv.style.height);
  3768.                 //bonkAPI.pixiCtx.x = w / 2;
  3769.                 //bonkAPI.pixiCtx.y = h / 2;
  3770.                 bonkAPI.pixiStage = 0;
  3771.                 for(let i = 0; i < bonkAPI.parentDraw.children.length; i++){
  3772.                     if(bonkAPI.parentDraw.children[i].constructor.name == "e"){
  3773.                         //console.log(bonkAPI.parentDraw);
  3774.                         bonkAPI.pixiStage = bonkAPI.parentDraw.children[i];
  3775.                         break;
  3776.                     }
  3777.                 }
  3778.                 let sendObj = {
  3779.                     container: bonkAPI.pixiCtx,
  3780.                     width: w,
  3781.                     height: h,
  3782.                 };
  3783.                 bonkAPI.events.fireEvent("graphicsUpdate", sendObj);
  3784.                 if(bonkAPI.pixiStage != 0 && !bonkAPI.pixiStage.children.includes(bonkAPI.pixiCtx)) {
  3785.                     bonkAPI.pixiStage.addChild(bonkAPI.pixiCtx);
  3786.                 }
  3787.             }
  3788.         }
  3789.     }
  3790.     return bonkAPI.originalRequestAnimationFrame.call(this,...args);
  3791. }
  3792.  
  3793. /**
  3794.  * When the map has changed.
  3795.  * @event mapSwitch
  3796.  * @type {object}
  3797.  * @property {PIXI} pixi - PIXI class in order to create graphics and containers.
  3798.  * @property {string} container - PIXI container to hold PIXI graphics.
  3799.  */
  3800. if(bonkAPI.events.hasEvent["graphicsReady"]) {
  3801.     let sendObj = {
  3802.         pixi: window.PIXI,
  3803.         container: bonkAPI.pixiCtx,
  3804.     }
  3805.     bonkAPI.events.fireEvent("graphicsReady", sendObj);
  3806. }
  3807. bonkHUD.loadStyleSettings();
  3808. bonkHUD.initialize();
  3809. bonkHUD.updateStyleSettings();
  3810. };
  3811.  
  3812. bonkLIB.checkDocumentReady = () => {
  3813.     if (document.readyState === "complete" || document.readyState === "interactive") {
  3814.         bonkLIB.onLoaded();
  3815.     } else {
  3816.         document.addEventListener("DOMContentLoaded", function () {
  3817.             bonkLIB.onLoaded();
  3818.         });
  3819.     }
  3820. };
  3821.  
  3822. // Call the function to check document readiness
  3823. bonkLIB.checkDocumentReady();
  3824.