☰

Survev-KrityHack

Aimbot, xray, tracer, better zoom, smoke/obstacle opacity, autoloot, player names...

目前为 2025-01-13 提交的版本，查看 最新版本。

  1. // ==UserScript==
  2. // @name         Survev-KrityHack
  3. // @namespace    https://github.com/Drino955/survev-krityhack
  4. // @version      0.2.1
  5. // @description  Aimbot, xray, tracer, better zoom, smoke/obstacle opacity, autoloot, player names...
  6. // @author       KrityTeam
  7. // @match        *://survev.io/*
  8. // @match        *://resurviv.biz/*
  9. // @icon         https://www.google.com/s2/favicons?domain=survev.io
  10. // @grant        none
  11. // @run-at       document-start
  12. // @webRequest   [{"selector":"*app-*.js","action":"cancel"}]
  13. // @webRequest   [{"selector":"*shared-*.js","action":"cancel"}]
  14. // @homepageURL  https://github.com/Drino955/survev-krityhack
  15. // @supportURL   https://github.com/Drino955/survev-krityhack/issues
  16. // ==/UserScript==
  17.  
  18.  
  19. console.log('Script injecting...')
  20.  
  21. window.gameOptimization = true;
  22. window.ping = {};
  23.  
  24. // cannot insert through tampermonkey require cause "Cannot use import statement outside a module"
  25. const appScript = document.createElement('script');
  26. appScript.type = 'module';
  27.  
  28. if (window.location.hostname === 'survev.io') {
  29.     console.log('Survev.io detected');
  30.     appScript.src = '//cdn.jsdelivr.net/gh/drino955/survev-krityhack@621cbd2bb8a2c9b9c4fbe11f892574a9af1dd9dc/survev/app.js';
  31. } else if(window.location.hostname === 'resurviv.biz')  {
  32.     console.log('Resurviv.biz detected');
  33.     appScript.src = '//cdn.jsdelivr.net/gh/drino955/survev-krityhack@621cbd2bb8a2c9b9c4fbe11f892574a9af1dd9dc/resurviv/app.js';
  34. }
  35.  
  36. appScript.onload = () => console.log('app.js loaded');
  37. appScript.onerror = (err) => console.error('Error in app.js loading:', err);
  38.  
  39.  
  40. const pixiScript = document.createElement('script');
  41. pixiScript.src = 'https://cdnjs.cloudflare.com/ajax/libs/pixi.js/7.0.3/pixi.min.js';
  42. pixiScript.onload = () => console.log('pixi.js loaded');
  43. pixiScript.onerror = (err) => console.error('Error in pixi.js loading:', err);
  44. let aimBotEnabled = true;
  45. let zoomEnabled = true;
  46. let meleeAttackEnabled = true;
  47. let spinBot = false;
  48. let autoSwitchEnabled = true;
  49.  
  50. let espEnabled = true;
  51. let xrayEnabled = true;
  52. let focusedEnemy = null;
  53.  
  54. const version = GM_info.script.version;
  55.  
  56.  
  57. const overlay = document.createElement('div');
  58. overlay.className = 'krity-overlay';
  59.  
  60. const krityTitle = document.createElement('h3');
  61. krityTitle.className = 'krity-title';
  62. krityTitle.innerText = `KrityHack ${version}`;
  63.  
  64. const styles = document.createElement('style');
  65. styles.innerHTML = `
  66. .krity-overlay{
  67.     position: absolute;
  68.     top: 128px;
  69.     left: 0px;
  70.     width: 100%;
  71.     pointer-events: None;
  72.     color: #fff;
  73.     font-family: monospace;
  74.     text-shadow: 0 0 5px rgba(0, 0, 0, .5);
  75.     z-index: 1;
  76. }
  77.  
  78. .krity-title{
  79.     text-align: center;
  80.     margin-top: 10px;
  81.     margin-bottom: 10px;
  82.     font-size: 25px;
  83.     text-shadow: 0 0 10px rgba(0, 0, 0, .9);
  84.     color: #fff;
  85.     font-family: monospace;
  86.     pointer-events: None;
  87. }
  88.  
  89. .krity-control{
  90.     text-align: center;
  91.     margin-top: 3px;
  92.     margin-bottom: 3px;
  93.     font-size: 18px;
  94. }
  95.  
  96. .aimbotDot{
  97.     position: absolute;
  98.     top: 0;
  99.     left: 0;
  100.     width: 10px;
  101.     height: 10px;
  102.     background-color: red;
  103.     transform: translateX(-50%) translateY(-50%);
  104.     display: none;
  105. }
  106.  
  107. #news-current ul{
  108.     margin-left: 20px;
  109.     padding-left: 6px;
  110. }
  111. `;
  112.  
  113. const fontAwesome = document.createElement('link');
  114. fontAwesome.rel = "stylesheet";
  115. fontAwesome.href = "https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.7.2/css/all.min.css";
  116.  
  117. const aimbotDot = document.createElement('div')
  118. aimbotDot.className = 'aimbotDot';
  119.  
  120. keybinds();
  121. removeCeilings();
  122. autoLoot();
  123. bootLoader(); // init game every time()
  124.  
  125. function keybinds(){
  126.     window.addEventListener('keyup', function (event) {
  127.         if (!window?.game?.ws) return;
  128.  
  129.         const validKeys = ['B', 'Z', 'M', 'Y', 'T'];
  130.         if (!validKeys.includes(String.fromCharCode(event.keyCode))) return;
  131.     
  132.         switch (String.fromCharCode(event.keyCode)) {
  133.             case 'B': 
  134.                 aimBotEnabled = !aimBotEnabled; 
  135.                 aimbotDot.style.display = 'None';
  136.                 window.lastAimPos = null;
  137.                 window.aimTouchMoveDir = null;
  138.                 break;
  139.             case 'Z': zoomEnabled = !zoomEnabled; break;
  140.             case 'M': 
  141.                 meleeAttackEnabled = !meleeAttackEnabled;
  142.                 window.aimTouchMoveDir = null;
  143.                 event.stopImmediatePropagation()
  144.                 event.stopPropagation();
  145.                 event.preventDefault();
  146.                 break;
  147.             case 'Y': spinBot = !spinBot; break;
  148.             case 'T': 
  149.                 if(focusedEnemy){
  150.                     focusedEnemy = null;
  151.                 }else{
  152.                     if (!enemyAimBot?.active || enemyAimBot?.netData?.dead) break;
  153.                     focusedEnemy = enemyAimBot;
  154.                 }
  155.                 break;
  156.             // case 'P': autoStopEnabled = !autoStopEnabled; break;
  157.             // case 'U': autoSwitchEnabled = !autoSwitchEnabled; break;
  158.             // case 'O': window.gameOptimization = !window.gameOptimization; break;
  159.         }
  160.         updateOverlay();
  161.     });
  162.     
  163.     window.addEventListener('keydown', function (event) {
  164.         if (!window?.game?.ws) return;
  165.  
  166.         const validKeys = ['M', 'T'];
  167.         if (!validKeys.includes(String.fromCharCode(event.keyCode))) return;
  168.     
  169.         switch (String.fromCharCode(event.keyCode)) {
  170.             case 'M': 
  171.                 event.stopImmediatePropagation()
  172.                 event.stopPropagation();
  173.                 event.preventDefault();
  174.                 break;
  175.             case 'T': 
  176.                 event.stopImmediatePropagation()
  177.                 event.stopPropagation();
  178.                 event.preventDefault();
  179.                 break;
  180.         }
  181.     });
  182.  
  183.     window.addEventListener('mousedown', function (event) {
  184.         if (event.button !== 1) return; // Only proceed if middle mouse button is clicked
  185.  
  186.         const mouseX = event.clientX;
  187.         const mouseY = event.clientY;
  188.  
  189.         const players = window.game.playerBarn.playerPool.pool;
  190.         const me = window.game.activePlayer;
  191.         const meTeam = getTeam(me);
  192.  
  193.         let enemy = null;
  194.         let minDistanceToEnemyFromMouse = Infinity;
  195.  
  196.         players.forEach((player) => {
  197.             // We miss inactive or dead players
  198.             if (!player.active || player.netData.dead || player.downed || me.__id === player.__id || getTeam(player) == meTeam) return;
  199.  
  200.             const screenPlayerPos = window.game.camera.pointToScreen({x: player.pos._x, y: player.pos._y});
  201.             const distanceToEnemyFromMouse = (screenPlayerPos.x - mouseX) ** 2 + (screenPlayerPos.y - mouseY) ** 2;
  202.  
  203.             if (distanceToEnemyFromMouse < minDistanceToEnemyFromMouse) {
  204.                 minDistanceToEnemyFromMouse = distanceToEnemyFromMouse;
  205.                 enemy = player;
  206.             }
  207.         });
  208.  
  209.         if (enemy) {
  210.             const enemyIndex = friends.indexOf(enemy.nameText._text);
  211.             if (~enemyIndex) {
  212.                 friends.splice(enemyIndex, 1);
  213.                 console.log(`Removed player with name ${enemy.nameText._text} from friends.`);
  214.             }else {
  215.                 friends.push(enemy.nameText._text);
  216.                 console.log(`Added player with name ${enemy.nameText._text} to friends.`);
  217.             }
  218.         }
  219.     });
  220. }
  221.  
  222. function removeCeilings(){
  223.     Object.defineProperty( Object.prototype, 'textureCacheIds', {
  224.         set( value ) {
  225.             this._textureCacheIds = value;
  226.     
  227.             if ( Array.isArray( value ) ) {
  228.                 const scope = this;
  229.     
  230.                 value.push = new Proxy( value.push, {
  231.                     apply( target, thisArgs, args ) {
  232.                         // console.log(args[0], scope, scope?.baseTexture?.cacheId);
  233.                         // console.log(scope, args[0]);
  234.                         if (args[0].includes('ceiling') && !args[0].includes('map-building-container-ceiling-05') || args[0].includes('map-snow-')) {
  235.                             Object.defineProperty( scope, 'valid', {
  236.                                 set( value ) {
  237.                                     this._valid = value;
  238.                                 },
  239.                                 get() {
  240.                                     return xrayEnabled ? false : this._valid;
  241.                                 }
  242.                             });
  243.                         }
  244.                         return Reflect.apply( ...arguments );
  245.     
  246.                     }
  247.                 });
  248.     
  249.             }
  250.     
  251.         },
  252.         get() {
  253.             return this._textureCacheIds;
  254.         }
  255.     });
  256. }
  257.  
  258. function autoLoot(){
  259.     Object.defineProperty(window, 'basicDataInfo', {
  260.         get () {
  261.             return this._basicDataInfo;
  262.         },
  263.         set(value) {
  264.             this._basicDataInfo = value;
  265.             
  266.             if (!value) return;
  267.             
  268.             Object.defineProperty(window.basicDataInfo, 'isMobile', {
  269.                 get () {
  270.                     return true;
  271.                 },
  272.                 set(value) {
  273.                 }
  274.             });
  275.             
  276.             Object.defineProperty(window.basicDataInfo, 'useTouch', {
  277.                 get () {
  278.                     return true;
  279.                 },
  280.                 set(value) {
  281.                 }
  282.             });
  283.             
  284.         }
  285.     });
  286. }
  287.  
  288. function bootLoader(){
  289.     Object.defineProperty(window, 'game', {
  290.         get () {
  291.             return this._game;
  292.         },
  293.         set(value) {
  294.             this._game = value;
  295.             
  296.             if (!value) return;
  297.             
  298.             initGame();
  299.             
  300.         }
  301.     });
  302. }
  303.  
  304. function overrideMousePos() {
  305.     Object.defineProperty(window.game.input.mousePos, 'x', {
  306.         get() {
  307.             if (window.game.input.mouseButtons['0'] && window.lastAimPos && window.game.activePlayer.localData.curWeapIdx != 3) {
  308.                 return window.lastAimPos.clientX;
  309.             }
  310.             if (!window.game.input.mouseButtons['0'] && !window.game.input.mouseButtons['2'] && window.game.activePlayer.localData.curWeapIdx != 3 && spinBot) {
  311.                 spinAngle += spinSpeed;
  312.                 return Math.cos(degreesToRadians(spinAngle)) * radius + window.innerWidth / 2;
  313.             }
  314.             return this._x;
  315.         },
  316.         set(value) {
  317.             this._x = value;
  318.         }
  319.     });
  320.  
  321.     Object.defineProperty(window.game.input.mousePos, 'y', {
  322.         get() {
  323.             if (window.game.input.mouseButtons['0'] && window.lastAimPos && window.game.activePlayer.localData.curWeapIdx != 3) {
  324.                 return window.lastAimPos.clientY;
  325.             }
  326.             if (!window.game.input.mouseButtons['0'] && !window.game.input.mouseButtons['2'] && window.game.activePlayer.localData.curWeapIdx != 3 && spinBot) {
  327.                 return Math.sin(degreesToRadians(spinAngle)) * radius + window.innerHeight / 2;
  328.             }
  329.             return this._y;
  330.         },
  331.         set(value) {
  332.             this._y = value;
  333.         }
  334.     });
  335. }
  336.  
  337. let tickerOneTime = false;
  338. function initGame() {
  339.     console.log('init game...........');
  340.  
  341.     window.lastAimPos = null;
  342.     window.aimTouchMoveDir = null;
  343.     enemyAimBot = null;
  344.     focusedEnemy = null;
  345.     friends = [];
  346.     lastFrames = {}; 
  347.  
  348.     const tasks = [
  349.         {isApplied: false, condition: () => window.game?.input?.mouseButtonsOld, action: bumpFire},
  350.         {isApplied: false, condition: () => window.game?.input?.mousePos, action: overrideMousePos},
  351.         {isApplied: false, condition: () => window.game?.activePlayer?.localData, action: betterZoom},
  352.         {isApplied: false, condition: () => Array.prototype.push === window.game?.smokeBarn?.particles.push, action: smokeOpacity},
  353.         {isApplied: false, condition: () => Array.prototype.push === window.game?.playerBarn?.playerPool?.pool.push, action: visibleNames},
  354.         {isApplied: false, condition: () => window.game?.pixi?._ticker && window.game?.activePlayer?.container && window.game?.activePlayer?.pos, action: () => { if (!tickerOneTime) { tickerOneTime = true; initTicker(); } } },
  355.     ];
  356.  
  357.     (function checkLocalData(){
  358.         if(!window?.game?.ws) return;
  359.  
  360.         console.log('Checking local data')
  361.  
  362.         console.log(
  363.             window.game?.activePlayer?.localData, 
  364.             window.game?.map?.obstaclePool?.pool,
  365.             window.game?.smokeBarn?.particles,
  366.             window.game?.playerBarn?.playerPool?.pool
  367.         );
  368.  
  369.         tasks.forEach(task => console.log(task.action, task.isApplied))
  370.         
  371.         tasks.forEach(task => {
  372.             if (task.isApplied || !task.condition()) return;
  373.             task.action();
  374.             task.isApplied = true;
  375.         });
  376.         
  377.         if (tasks.some(task => !task.isApplied)) setTimeout(checkLocalData, 5);
  378.         else console.log('All functions applied, stopping loop.');
  379.     })();
  380.  
  381.     updateOverlay();
  382. }
  383.  
  384. function initTicker(){
  385.     window.game?.pixi?._ticker?.add(esp);
  386.     window.game?.pixi?._ticker?.add(aimBot);
  387.     window.game?.pixi?._ticker?.add(autoSwitch);
  388.     window.game?.pixi?._ticker?.add(obstacleOpacity);
  389.     window.game?.pixi?._ticker?.add(grenadeTimer);
  390. }
  391.  
  392. function bumpFire(){
  393.     Object.defineProperty( window.game.input, 'mouseButtonsOld', {
  394.         set( value ) {
  395.             // console.log(value);
  396.             // console.table(value);
  397.             value[0] = false;
  398.             this._value = value;
  399.         },
  400.         get() {
  401.             return this._value || {};
  402.         }
  403.     });
  404. }
  405.  
  406. function betterZoom(){
  407.     Object.defineProperty(window.game.camera, 'zoom', {
  408.         get() {
  409.             return Math.max(window.game.camera.targetZoom - (zoomEnabled ? 0.45 : 0), 0.35);
  410.         },
  411.         set(value) {
  412.         }
  413.     });
  414.  
  415.     let oldScope = window.game.activePlayer.localData.scope;
  416.     Object.defineProperty(window.game.camera, 'targetZoom', {
  417.         get(){
  418.             return this._targetZoom;
  419.         },
  420.         set(value) {
  421.             const newScope = window.game.activePlayer.localData.scope;
  422.             const inventory = window.game.activePlayer.localData.inventory;
  423.  
  424.             const scopes = ['1xscope', '2xscope', '4xscope', '8xscope', '15xscope']
  425.  
  426.             // console.log(value, oldScope, newScope, newScope == oldScope, (inventory['2xscope'] || inventory['4xscope'] || inventory['8xscope'] || inventory['15xscope']));
  427.             if ( (newScope == oldScope) && (inventory['2xscope'] || inventory['4xscope'] || inventory['8xscope'] || inventory['15xscope']) && value >= this._targetZoom
  428.                 || scopes.indexOf(newScope) > scopes.indexOf(oldScope) && value >= this._targetZoom
  429.             ) return;
  430.  
  431.             oldScope = window.game.activePlayer.localData.scope;
  432.  
  433.             this._targetZoom = value;
  434.         }
  435.     });
  436. }
  437.  
  438. function smokeOpacity(){
  439.     console.log('smokeopacity')
  440.     
  441.     const particles = window.game.smokeBarn.particles;
  442.     console.log('smokeopacity', particles, window.game.smokeBarn.particles)
  443.     particles.push = new Proxy( particles.push, {
  444.         apply( target, thisArgs, args ) {
  445.             console.log('smokeopacity', args[0]);
  446.             const particle = args[0];
  447.  
  448.             Object.defineProperty(particle.sprite, 'alpha', {
  449.                 get() {
  450.                     return 0.12;
  451.                 },
  452.                 set(value) {
  453.                 }
  454.             });
  455.  
  456.             return Reflect.apply( ...arguments );
  457.  
  458.         }
  459.     });
  460.  
  461.     particles.forEach(particle => {
  462.         Object.defineProperty(particle.sprite, 'alpha', {
  463.             get() {
  464.                 return 0.12;
  465.             },
  466.             set(value) {
  467.             }
  468.         });
  469.     });
  470. }
  471.  
  472. function obstacleOpacity(){
  473.     window.game.map.obstaclePool.pool.forEach(obstacle => {
  474.         if (!['bush', 'tree', 'table', 'stairs'].some(substring => obstacle.type.includes(substring))) return;
  475.         obstacle.sprite.alpha = 0.45
  476.     });
  477. }
  478.  
  479. function getTeam(player) {
  480.     return Object.keys(game.playerBarn.teamInfo).find(team => game.playerBarn.teamInfo[team].playerIds.includes(player.__id));
  481. }
  482.  
  483. const GREEN = 0x00ff00;
  484. const BLUE = 0x00f3f3;
  485. const RED = 0xff0000;
  486. const WHITE = 0xffffff;
  487. function visibleNames(){
  488.     const pool = window.game.playerBarn.playerPool.pool;
  489.  
  490.     console.log('visibleNames', pool)
  491.  
  492.     pool.push = new Proxy( pool.push, {
  493.         apply( target, thisArgs, args ) {
  494.             const player = args[0];
  495.             Object.defineProperty(player.nameText, 'visible', {
  496.                 get(){
  497.                     const me = window.game.activePlayer;
  498.                     const meTeam = getTeam(me);
  499.                     const playerTeam = getTeam(player);
  500.                     // console.log('visible', player?.nameText?._text, playerTeam === meTeam ? BLUE : RED, player, me, playerTeam, meTeam)
  501.                     this.tint = playerTeam === meTeam ? BLUE : friends.includes(player.nameText._text) ? GREEN : RED;
  502.                     player.nameText.style.fontSize = 40;
  503.                     return true;
  504.                 },
  505.                 set(value){
  506.                 }
  507.             });
  508.  
  509.             return Reflect.apply( ...arguments );
  510.         }
  511.     });
  512.  
  513.     pool.forEach(player => {
  514.         Object.defineProperty(player.nameText, 'visible', {
  515.             get(){
  516.                 const me = window.game.activePlayer;
  517.                 const meTeam = getTeam(me);
  518.                 const playerTeam = getTeam(player);
  519.                 // console.log('visible', player?.nameText?._text, playerTeam === meTeam ? BLUE : RED, player, me, playerTeam, meTeam)
  520.                 this.tint = playerTeam === meTeam ? BLUE : RED;
  521.                 player.nameText.style.fontSize = 40;
  522.                 return true;
  523.             },
  524.             set(value){
  525.             }
  526.         });
  527.     });
  528. }
  529.  
  530. let laserDrawerEnabled = true,
  531.     lineDrawerEnabled = true,
  532.     nadeDrawerEnabled = true;
  533. let friends = [];
  534. function esp(){
  535.     const pixi = window.game.pixi; 
  536.     const me = window.game.activePlayer;
  537.     const players = window.game.playerBarn.playerPool.pool;
  538.  
  539.     // We check if there is an object of Pixi, otherwise we create a new
  540.     if (!pixi || me?.container == undefined) {
  541.         // console.error("PIXI object not found in game.");
  542.         return;
  543.     }
  544.  
  545.     const meX = me.pos.x;
  546.     const meY = me.pos.y;
  547.  
  548.     const meTeam = getTeam(me);
  549.     
  550.     try{
  551.  
  552.     // lineDrawer
  553.     if (lineDrawerEnabled){
  554.         if (!me.container.lineDrawer) {
  555.             me.container.lineDrawer = new PIXI.Graphics();
  556.             me.container.addChild(me.container.lineDrawer);
  557.         }
  558.             
  559.         const lineDrawer = me.container.lineDrawer;
  560.         lineDrawer.clear(); // Cleaning previous lines
  561.     
  562.         // For each player
  563.         players.forEach((player) => {
  564.             // We miss inactive or dead players
  565.             if (!player.active || player.netData.dead || me.__id == player.__id) return;
  566.     
  567.             const playerX = player.pos.x;
  568.             const playerY = player.pos.y;
  569.     
  570.             const playerTeam = getTeam(player);
  571.     
  572.             // We calculate the color of the line (for example, red for enemies)
  573.             const lineColor = playerTeam === meTeam ? BLUE : friends.includes(player.nameText._text) ? GREEN : me.layer === player.layer && !player.downed ? RED : WHITE;
  574.     
  575.             // We draw a line from the current player to another player
  576.             lineDrawer.lineStyle(2, lineColor, 1);
  577.             lineDrawer.moveTo(0, 0); // Container Container Center
  578.             lineDrawer.lineTo(
  579.                 (playerX - meX) * 16,
  580.                 (meY - playerY) * 16
  581.             );
  582.         });
  583.     }
  584.  
  585.     // nadeDrawer
  586.     if (nadeDrawerEnabled){
  587.         if (!me.container.nadeDrawer) {
  588.             me.container.nadeDrawer = new PIXI.Graphics();
  589.             me.container.addChild(me.container.nadeDrawer);
  590.         }
  591.             
  592.         const nadeDrawer = me.container.nadeDrawer;
  593.         nadeDrawer.clear();
  594.     
  595.         Object.values(window.game.objectCreator.idToObj)
  596.             .filter(obj => {
  597.                 const isValid = ( obj.__type === 9 && obj.type !== "smoke" )
  598.                     ||  (
  599.                             obj.smokeEmitter &&
  600.                             window.objects[obj.type].explosion);
  601.                 return isValid;
  602.             })
  603.             .forEach(obj => {
  604.                 if(obj.layer !== me.layer) {
  605.                     nadeDrawer.beginFill(0xffffff, 0.3);
  606.                 } else {
  607.                     nadeDrawer.beginFill(0xff0000, 0.2);
  608.                 }
  609.                 nadeDrawer.drawCircle(
  610.                     (obj.pos.x - meX) * 16,
  611.                     (meY - obj.pos.y) * 16,
  612.                     (window.explosions[
  613.                         window.throwable[obj.type]?.explosionType ||
  614.                         window.objects[obj.type].explosion
  615.                             ].rad.max +
  616.                         1) *
  617.                     16
  618.                 );
  619.                 nadeDrawer.endFill();
  620.             });
  621.     }
  622.  
  623.     // flashlightDrawer(laserDrawer)
  624.     if (laserDrawerEnabled) {
  625.         const curWeapon = findWeap(me);
  626.         const curBullet = findBullet(curWeapon);
  627.         
  628.         if ( !me.container.laserDrawer ) {
  629.             me.container.laserDrawer = new PIXI.Graphics();
  630.             me.container.addChildAt(me.container.laserDrawer, 0);
  631.         }
  632.         const laserDrawer = me.container.laserDrawer;
  633.         laserDrawer.clear();
  634.             
  635.     
  636.         function laserPointer(
  637.             curBullet,
  638.             curWeapon,
  639.             acPlayer,
  640.             color = 0x0000ff,
  641.             opacity = 0.3,
  642.         ) {
  643.             const { pos: acPlayerPos, posOld: acPlayerPosOld } = acPlayer;
  644.     
  645.             const dateNow = performance.now();
  646.     
  647.             if ( !(acPlayer.__id in lastFrames) ) lastFrames[acPlayer.__id] = [];
  648.             lastFrames[acPlayer.__id].push([dateNow, { ...acPlayerPos }]);
  649.     
  650.             if (lastFrames[acPlayer.__id].length < 10) return;
  651.     
  652.             if (lastFrames[acPlayer.__id].length > 10){
  653.                 lastFrames[acPlayer.__id].shift();
  654.             }
  655.     
  656.             const deltaTime = (dateNow - lastFrames[acPlayer.__id][0][0]) / 1000; // Time since last frame in seconds
  657.     
  658.             const acPlayerVelocity = {
  659.                 x: (acPlayerPos._x - lastFrames[acPlayer.__id][0][1]._x) / deltaTime,
  660.                 y: (acPlayerPos._y - lastFrames[acPlayer.__id][0][1]._y) / deltaTime,
  661.             };
  662.     
  663.             let lasic = {};
  664.         
  665.             let isMoving = !!(acPlayerVelocity.x || acPlayerVelocity.y);
  666.         
  667.             if(curBullet) {
  668.                 lasic.active = true;
  669.                 lasic.range = curBullet.distance * 16.25;
  670.                 let atan;
  671.                 if (acPlayer == me && !window.game.input.mouseButtons['0']){
  672.                     //local rotation
  673.                     atan = Math.atan2(
  674.                         window.game.input.mousePos._y - window.innerHeight / 2,
  675.                         window.game.input.mousePos._x - window.innerWidth / 2,
  676.                     );
  677.                 }else{
  678.                     atan = Math.atan2(
  679.                         acPlayer.dir.x,
  680.                         acPlayer.dir.y
  681.                     ) 
  682.                     -
  683.                     Math.PI / 2;
  684.                 }
  685.                 lasic.direction = atan;
  686.                 lasic.angle =
  687.                     ((curWeapon.shotSpread +
  688.                         (isMoving ? curWeapon.moveSpread : 0)) *
  689.                         0.01745329252) /
  690.                     2;
  691.             } else {
  692.                 lasic.active = false;
  693.             }
  694.         
  695.             if(!lasic.active) {
  696.                 return;
  697.             }
  698.     
  699.             const center = {
  700.                 x: (acPlayerPos._x - me.pos._x) * 16,
  701.                 y: (me.pos._y - acPlayerPos._y) * 16,
  702.             };
  703.             const radius = lasic.range;
  704.             let angleFrom = lasic.direction - lasic.angle;
  705.             let angleTo = lasic.direction + lasic.angle;
  706.             angleFrom =
  707.                 angleFrom > Math.PI * 2
  708.                     ? angleFrom - Math.PI * 2
  709.                     : angleFrom < 0
  710.                     ? angleFrom + Math.PI * 2
  711.                     : angleFrom;
  712.             angleTo =
  713.                 angleTo > Math.PI * 2
  714.                     ? angleTo - Math.PI * 2
  715.                     : angleTo < 0
  716.                     ? angleTo + Math.PI * 2
  717.                     : angleTo;
  718.             laserDrawer.beginFill(color, opacity);
  719.             laserDrawer.moveTo(center.x, center.y);
  720.             laserDrawer.arc(center.x, center.y, radius, angleFrom, angleTo);
  721.             laserDrawer.lineTo(center.x, center.y);
  722.             laserDrawer.endFill();
  723.         }
  724.         
  725.         
  726.         laserPointer(
  727.             curBullet,
  728.             curWeapon,
  729.             me,
  730.         );
  731.         
  732.         players
  733.             .filter(player => player.active || !player.netData.dead || me.__id !== player.__id || me.layer === player.layer || getTeam(player) != meTeam)
  734.             .forEach(enemy => {
  735.                 const enemyWeapon = findWeap(enemy);
  736.                 laserPointer(
  737.                     findBullet(enemyWeapon),
  738.                     enemyWeapon,
  739.                     enemy,
  740.                     "0",
  741.                     0.2,
  742.                 )
  743.             });
  744.     };
  745.  
  746.     }catch(err){
  747.         console.error('esp', err)
  748.     }
  749. }
  750.  
  751. const inputCommands = {
  752.     Cancel: 6,
  753.     Count: 36,
  754.     CycleUIMode: 30,
  755.     EmoteMenu: 31,
  756.     EquipFragGrenade: 15,
  757.     EquipLastWeap: 19,
  758.     EquipMelee: 13,
  759.     EquipNextScope: 22,
  760.     EquipNextWeap: 17,
  761.     EquipOtherGun: 20,
  762.     EquipPrevScope: 21,
  763.     EquipPrevWeap: 18,
  764.     EquipPrimary: 11,
  765.     EquipSecondary: 12,
  766.     EquipSmokeGrenade: 16,
  767.     EquipThrowable: 14,
  768.     Fire: 4,
  769.     Fullscreen: 33,
  770.     HideUI: 34,
  771.     Interact: 7,
  772.     Loot: 10,
  773.     MoveDown: 3,
  774.     MoveLeft: 0,
  775.     MoveRight: 1,
  776.     MoveUp: 2,
  777.     Reload: 5,
  778.     Revive: 8,
  779.     StowWeapons: 27,
  780.     SwapWeapSlots: 28,
  781.     TeamPingMenu: 32,
  782.     TeamPingSingle: 35,
  783.     ToggleMap: 29,
  784.     Use: 9,
  785.     UseBandage: 23,
  786.     UseHealthKit: 24,
  787.     UsePainkiller: 26,
  788.     UseSoda: 25,
  789. };
  790.  
  791. let inputs = [];
  792. window.initGameControls = function(gameControls){
  793.     for (const command of inputs){
  794.         gameControls.addInput(inputCommands[command]);
  795.     }
  796.     inputs = [];
  797.  
  798.     // autoMelee
  799.     if (window.game.input.mouseButtons['0'] && window.aimTouchMoveDir) {
  800.         if (window.aimTouchDistanceToEnemy < 4) gameControls.addInput(inputCommands['EquipMelee']);
  801.         gameControls.touchMoveActive = true;
  802.         gameControls.touchMoveLen = 255;
  803.         gameControls.touchMoveDir.x = window.aimTouchMoveDir.x;
  804.         gameControls.touchMoveDir.y = window.aimTouchMoveDir.y;
  805.     }
  806.  
  807.     return gameControls
  808. }
  809.  
  810. function degreesToRadians(degrees) {
  811.     return degrees * (Math.PI / 180);
  812. }
  813.  
  814.  
  815. let spinAngle = 0;
  816. const radius = 100; // The radius of the circle
  817. const spinSpeed = 37.5; // Rotation speed (increase for faster speed)
  818. let date = performance.now();
  819. let enemyAimBot = null;
  820. function aimBot() {
  821.  
  822.     if (!aimBotEnabled) return;
  823.  
  824.     const players = window.game.playerBarn.playerPool.pool;
  825.     const me = window.game.activePlayer;
  826.  
  827.     try {
  828.         const meTeam = getTeam(me);
  829.  
  830.         let enemy = null;
  831.         let minDistanceToEnemyFromMouse = Infinity;
  832.         
  833.         if (focusedEnemy && focusedEnemy.active && !focusedEnemy.netData.dead) {
  834.             enemy = focusedEnemy;
  835.         }else{
  836.             if (focusedEnemy){
  837.                 focusedEnemy = null;
  838.                 updateOverlay();
  839.             }
  840.  
  841.             players.forEach((player) => {
  842.                 // We miss inactive or dead players
  843.                 if (!player.active || player.netData.dead || player.downed || me.__id === player.__id || me.layer !== player.layer || getTeam(player) == meTeam || friends.includes(player.nameText._text)) return;
  844.     
  845.                 const screenPlayerPos = window.game.camera.pointToScreen({x: player.pos._x, y: player.pos._y});
  846.                 // const distanceToEnemyFromMouse = Math.hypot(screenPlayerPos.x - window.game.input.mousePos._x, screenPlayerPos.y - window.game.input.mousePos._y);
  847.                 const distanceToEnemyFromMouse = (screenPlayerPos.x - window.game.input.mousePos._x) ** 2 + (screenPlayerPos.y - window.game.input.mousePos._y) ** 2;
  848.                 
  849.                 if (distanceToEnemyFromMouse < minDistanceToEnemyFromMouse) {
  850.                     minDistanceToEnemyFromMouse = distanceToEnemyFromMouse;
  851.                     enemy = player;
  852.                 }
  853.             });
  854.         }
  855.  
  856.         if (enemy) {
  857.             const meX = me.pos._x;
  858.             const meY = me.pos._y;
  859.             const enemyX = enemy.pos._x;
  860.             const enemyY = enemy.pos._y;
  861.  
  862.             const distanceToEnemy = Math.hypot(meX - enemyX, meY - enemyY);
  863.             // const distanceToEnemy = (meX - enemyX) ** 2 + (meY - enemyY) ** 2;
  864.  
  865.             if (enemy != enemyAimBot) {
  866.                 enemyAimBot = enemy;
  867.                 lastFrames[enemy.__id] = [];
  868.             }
  869.  
  870.             const predictedEnemyPos = calculatePredictedPosForShoot(enemy, me);
  871.  
  872.             if (!predictedEnemyPos) return;
  873.  
  874.             window.lastAimPos = {
  875.                 clientX: predictedEnemyPos.x,
  876.                 clientY: predictedEnemyPos.y,
  877.             }
  878.             
  879.             // AutoMelee
  880.             if(meleeAttackEnabled && distanceToEnemy <= 8) {
  881.                 const moveAngle = calcAngle(enemy.pos, me.pos) + Math.PI;
  882.                 window.gameControls.touchMoveActive = true;
  883.                 window.aimTouchMoveDir = {
  884.                     x: Math.cos(moveAngle),
  885.                     y: Math.sin(moveAngle),
  886.                 }
  887.                 window.aimTouchDistanceToEnemy = distanceToEnemy;
  888.             }else{
  889.                 window.aimTouchMoveDir = null;
  890.                 window.aimTouchDistanceToEnemy = null;
  891.             }
  892.  
  893.             if (aimbotDot.style.left !== predictedEnemyPos.x + 'px' || aimbotDot.style.top !== predictedEnemyPos.y + 'px') {
  894.                 aimbotDot.style.left = predictedEnemyPos.x + 'px';
  895.                 aimbotDot.style.top = predictedEnemyPos.y + 'px';
  896.                 aimbotDot.style.display = 'block';
  897.             }
  898.         }else{
  899.             window.aimTouchMoveDir = null;
  900.             window.lastAimPos = null;
  901.             aimbotDot.style.display = 'none';
  902.         }
  903.  
  904.         date = performance.now();
  905.     } catch (error) {
  906.         console.error("Error in aimBot:", error);
  907.     }
  908. }
  909.  
  910. function calcAngle(playerPos, mePos){
  911.     const dx = mePos._x - playerPos._x;
  912.     const dy = mePos._y - playerPos._y;
  913.  
  914.     return Math.atan2(dy, dx);
  915. }
  916.  
  917. window.lastFrames = {};
  918. function calculatePredictedPosForShoot(enemy, curPlayer) {
  919.     if (!enemy || !curPlayer) {
  920.         console.log("Missing enemy or player data");
  921.         return null;
  922.     }
  923.     
  924.     const { pos: enemyPos } = enemy;
  925.     const { pos: curPlayerPos } = curPlayer;
  926.  
  927.     const dateNow = performance.now();
  928.  
  929.     if ( !(enemy.__id in lastFrames) ) lastFrames[enemy.__id] = [];
  930.     lastFrames[enemy.__id].push([dateNow, { ...enemyPos }]);
  931.  
  932.     if (lastFrames[enemy.__id].length < 10) {
  933.         console.log("Insufficient data for prediction, using current position");
  934.         return window.game.camera.pointToScreen({x: enemyPos._x, y: enemyPos._y});
  935.     }
  936.  
  937.     if (lastFrames[enemy.__id].length > 10){
  938.         lastFrames[enemy.__id].shift();
  939.     }
  940.  
  941.     const deltaTime = (dateNow - lastFrames[enemy.__id][0][0]) / 1000; // Time since last frame in seconds
  942.  
  943.     const enemyVelocity = {
  944.         x: (enemyPos._x - lastFrames[enemy.__id][0][1]._x) / deltaTime,
  945.         y: (enemyPos._y - lastFrames[enemy.__id][0][1]._y) / deltaTime,
  946.     };
  947.  
  948.     const weapon = findWeap(curPlayer);
  949.     const bullet = findBullet(weapon);
  950.  
  951.     let bulletSpeed;
  952.     if (!bullet) {
  953.         bulletSpeed = 1000;
  954.     }else{
  955.         bulletSpeed = bullet.speed;
  956.     }
  957.  
  958.  
  959.     // Quadratic equation for time prediction
  960.     const vex = enemyVelocity.x;
  961.     const vey = enemyVelocity.y;
  962.     const dx = enemyPos._x - curPlayerPos._x;
  963.     const dy = enemyPos._y - curPlayerPos._y;
  964.     const vb = bulletSpeed;
  965.  
  966.     const a = vb ** 2 - vex ** 2 - vey ** 2;
  967.     const b = -2 * (vex * dx + vey * dy);
  968.     const c = -(dx ** 2) - (dy ** 2);
  969.  
  970.     let t; 
  971.  
  972.     if (Math.abs(a) < 1e-6) {
  973.         console.log('Linear solution bullet speed is much greater than velocity')
  974.         t = -c / b;
  975.     } else {
  976.         const discriminant = b ** 2 - 4 * a * c;
  977.  
  978.         if (discriminant < 0) {
  979.             console.log("No solution, shooting at current position");
  980.             return window.game.camera.pointToScreen({x: enemyPos._x, y: enemyPos._y});
  981.         }
  982.  
  983.         const sqrtD = Math.sqrt(discriminant);
  984.         const t1 = (-b - sqrtD) / (2 * a);
  985.         const t2 = (-b + sqrtD) / (2 * a);
  986.  
  987.         t = Math.min(t1, t2) > 0 ? Math.min(t1, t2) : Math.max(t1, t2);
  988.     }
  989.  
  990.  
  991.     if (t < 0) {
  992.         console.log("Negative time, shooting at current position");
  993.         return window.game.camera.pointToScreen({x: enemyPos._x, y: enemyPos._y});
  994.     }
  995.  
  996.     // console.log(`A bullet with the enemy will collide through ${t}`)
  997.  
  998.     const predictedPos = {
  999.         x: enemyPos._x + vex * t,
  1000.         y: enemyPos._y + vey * t,
  1001.     };
  1002.  
  1003.     return window.game.camera.pointToScreen(predictedPos);
  1004. }
  1005.  
  1006. function findWeap(player) {
  1007.     const weapType = player.netData.activeWeapon;
  1008.     return weapType && window.guns[weapType] ? window.guns[weapType] : null;
  1009. }
  1010.  
  1011. function findBullet(weapon) {
  1012.     return weapon ? window.bullets[weapon.bulletType] : null;
  1013. }
  1014.  
  1015.  
  1016. function updateOverlay() {
  1017.     overlay.innerHTML = ``;
  1018.  
  1019.     const controls = [
  1020.         [ '[B] AimBot:', aimBotEnabled, aimBotEnabled ? 'ON' : 'OFF' ],
  1021.         [ '[Z] Zoom:', zoomEnabled, zoomEnabled ? 'ON' : 'OFF' ],
  1022.         [ '[M] MeleeAtk:', meleeAttackEnabled, meleeAttackEnabled ? 'ON' : 'OFF' ],
  1023.         [ '[Y] SpinBot:', spinBot, spinBot ? 'ON' : 'OFF' ],
  1024.         [ '[T] FocusedEnemy:', focusedEnemy, focusedEnemy?.nameText?._text ? focusedEnemy?.nameText?._text : 'OFF' ],
  1025.         // [ '[O] gameOptimization:', gameOptimization ],
  1026.     ];
  1027.  
  1028.     controls.forEach((control, index) => {
  1029.         let [name, isEnabled, optionalText] = control;
  1030.         text = `${name} ${optionalText}`;
  1031.  
  1032.         const line = document.createElement('p');
  1033.         line.className = 'krity-control';
  1034.         line.style.opacity = isEnabled ? 1 : 0.5;
  1035.         line.textContent = text;
  1036.         overlay.appendChild(line);
  1037.     });
  1038. }
  1039.  
  1040.  
  1041. const ammo = [
  1042.     {
  1043.         name: "",
  1044.         ammo: null,
  1045.         lastShotDate: Date.now()
  1046.     },
  1047.     {
  1048.         name: "",
  1049.         ammo: null,
  1050.         lastShotDate: Date.now()
  1051.     },
  1052.     {
  1053.         name: "",
  1054.         ammo: null,
  1055.     },
  1056.     {
  1057.         name: "",
  1058.         ammo: null,
  1059.     },
  1060. ]
  1061. function autoSwitch(){
  1062.     if (!autoSwitchEnabled) return;
  1063.  
  1064.     try {
  1065.     const curWeapIdx = window.game.activePlayer.localData.curWeapIdx;
  1066.     const weaps = window.game.activePlayer.localData.weapons;
  1067.     const curWeap = weaps[curWeapIdx];
  1068.     const shouldSwitch = gun => {
  1069.         let s = false;
  1070.         try {
  1071.             s =
  1072.                 (window.guns[gun].fireMode === "single"
  1073.                 || window.guns[gun].fireMode === "burst") 
  1074.                 && window.guns[gun].fireDelay >= 0.45;
  1075.         }
  1076.         catch (e) {
  1077.         }
  1078.         return s;
  1079.     }
  1080.     weapsEquip = ['EquipPrimary', 'EquipSecondary']
  1081.     if(curWeap.ammo !== ammo[curWeapIdx].ammo) {
  1082.         otherWeapIdx = (curWeapIdx == 0) ? 1 : 0
  1083.         otherWeap = weaps[otherWeapIdx]
  1084.         if ((curWeap.ammo < ammo[curWeapIdx].ammo || (ammo[curWeapIdx].ammo === 0 && curWeap.ammo > ammo[curWeapIdx].ammo && window.game.input.mouseButtons['0'])) && shouldSwitch(curWeap.type) && curWeap.type == ammo[curWeapIdx].type) {
  1085.             ammo[curWeapIdx].lastShotDate = Date.now();
  1086.             console.log("Switching weapon due to ammo change");
  1087.             if ( shouldSwitch(otherWeap.type) && otherWeap.ammo) { inputs.push(weapsEquip[otherWeapIdx]); } // && ammo[curWeapIdx].ammo !== 0
  1088.             else if ( otherWeap.type !== "" ) { inputs.push(weapsEquip[otherWeapIdx]); inputs.push(weapsEquip[curWeapIdx]); }
  1089.             else { inputs.push('EquipMelee'); inputs.push(weapsEquip[curWeapIdx]); }
  1090.         }
  1091.         ammo[curWeapIdx].ammo = curWeap.ammo
  1092.         ammo[curWeapIdx].type = curWeap.type
  1093.     }
  1094.     }catch(err){}
  1095. }
  1096.  
  1097. document.addEventListener('DOMContentLoaded', () => {
  1098.     document.head.append(fontAwesome);
  1099.     document.head.append(styles);
  1100.     document.head.append(appScript);
  1101.     document.head.append(pixiScript);
  1102.     document.querySelector('#ui-game').append(overlay);
  1103.     document.querySelector('#ui-top-left').insertBefore(krityTitle, document.querySelector('#ui-top-left').firstChild);
  1104.     document.querySelector('#ui-game').append(aimbotDot);
  1105.  
  1106.     new GameMod(); // AlguenClient
  1107. });
  1108.  
  1109. let colors = {
  1110.     container_06: 14934793,
  1111.     barn_02: 14934793,
  1112.     stone_02: 1654658,
  1113.     tree_03: 16777215,
  1114.     stone_04: 0xeb175a,
  1115.     stone_05: 0xeb175a,
  1116.     bunker_storm_01: 14934793,
  1117. },
  1118. sizes = {
  1119.     stone_02: 4,
  1120.     tree_03: 2,
  1121.     stone_04: 2,
  1122.     stone_05: 2,
  1123. };
  1124.  
  1125. window.mapColorizing = map => {
  1126.     map.forEach(object => {
  1127.         if ( !colors[object.obj.type] ) return;
  1128.         object.shapes.forEach(shape => {
  1129.             shape.color = colors[object.obj.type];
  1130.             console.log(object);
  1131.             if ( !sizes[object.obj.type] ) return;
  1132.             shape.scale = sizes[object.obj.type];
  1133.             console.log(object);
  1134.         });
  1135.     });
  1136. }
  1137.  
  1138.  
  1139.  
  1140. let lastTime = Date.now();
  1141. let showing = false;
  1142. let timer = null;
  1143. function grenadeTimer(){
  1144.     try{
  1145.     let elapsed = (Date.now() - lastTime) / 1000;
  1146.     const player = window.game.activePlayer;
  1147.     const activeItem = player.netData.activeWeapon;
  1148.  
  1149.     if (3 !== window.game.activePlayer.localData.curWeapIdx 
  1150.         || player.throwableState !== "cook"
  1151.         || (!activeItem.includes('frag') && !activeItem.includes('mirv') && !activeItem.includes('martyr_nade'))
  1152.     )
  1153.         return (
  1154.             (showing = false),
  1155.             timer && timer.destroy(),
  1156.             (timer = false)
  1157.         );
  1158.     const time = 4;
  1159.  
  1160.     if(elapsed > time) {
  1161.         showing = false;
  1162.     }
  1163.     if(!showing) {
  1164.         if(timer) {
  1165.             timer.destroy();
  1166.         }
  1167.         timer = new window.pieTimerClass();
  1168.         window.game.pixi.stage.addChild(timer.container);
  1169.         timer.start("Grenade", 0, time);
  1170.         showing = true;
  1171.         lastTime = Date.now();
  1172.         return;
  1173.     }
  1174.     timer.update(elapsed - timer.elapsed, window.game.camera);
  1175.     }catch(err){}
  1176. }
  1177.  
  1178.  
  1179. // alguen client
  1180. window.GameMod = class GameMod { // metka mod
  1181.     constructor() {
  1182.         this.lastFrameTime = performance.now();
  1183.         this.frameCount = 0;
  1184.         this.fps = 0;
  1185.         this.kills = 0;
  1186.         this.setAnimationFrameCallback();
  1187.         this.isFpsVisible = true;
  1188.         this.isPingVisible = true;
  1189.         this.isKillsVisible = true;
  1190.         this.isMenuVisible = true;
  1191.         this.isClean = false;
  1192.  
  1193.  
  1194.         this.initCounter("fpsCounter", "isFpsVisible", this.updateFpsVisibility.bind(this));
  1195.         this.initCounter("pingCounter", "isPingVisible", this.updatePingVisibility.bind(this));
  1196.         this.initCounter("killsCounter", "isKillsVisible", this.updateKillsVisibility.bind(this));
  1197.  
  1198.         this.initMenu();
  1199.         this.initRules();
  1200.         this.loadBackgroundFromLocalStorage();
  1201.         this.loadLocalStorage();
  1202.         this.startUpdateLoop();
  1203.         this.setupWeaponBorderHandler();
  1204.         this.setupKeyListeners();
  1205.     }
  1206.  
  1207.     initCounter(id, visibilityKey, updateVisibilityFn) {
  1208.         this[id] = document.createElement("div");
  1209.         this[id].id = id;
  1210.         Object.assign(this[id].style, {
  1211.             color: "white",
  1212.             backgroundColor: "rgba(0, 0, 0, 0.2)",
  1213.             padding: "5px 10px",
  1214.             marginTop: "10px",
  1215.             borderRadius: "5px",
  1216.             fontFamily: "Arial, sans-serif",
  1217.             fontSize: "14px",
  1218.             zIndex: "10000",
  1219.             pointerEvents: "none",
  1220.         });
  1221.  
  1222.         const uiTopLeft = document.getElementById("ui-top-left");
  1223.         if (uiTopLeft) {
  1224.             uiTopLeft.appendChild(this[id]);
  1225.         }
  1226.  
  1227.         updateVisibilityFn();
  1228.     }
  1229.  
  1230.     updateFpsVisibility() {
  1231.         this.updateVisibility("fpsCounter", this.isFpsVisible);
  1232.     }
  1233.  
  1234.     updatePingVisibility() {
  1235.         this.updateVisibility("pingCounter", this.isPingVisible);
  1236.     }
  1237.  
  1238.     updateKillsVisibility() {
  1239.         this.updateVisibility("killsCounter", this.isKillsVisible);
  1240.     }
  1241.  
  1242.  
  1243.     updateVisibility(id, isVisible) {
  1244.         if (this[id]) {
  1245.             this[id].style.display = isVisible ? "block" : "none";
  1246.             this[id].style.backgroundColor = isVisible
  1247.                 ? "rgba(0, 0, 0, 0.2)"
  1248.                 : "transparent";
  1249.         }
  1250.     }
  1251.  
  1252.     toggleFpsDisplay() {
  1253.       this.isFpsVisible = !this.isFpsVisible;
  1254.       this.updateFpsVisibility();
  1255.     }
  1256.     
  1257.     setAnimationFrameCallback() {
  1258.         this.animationFrameCallback = (callback) => setTimeout(callback, 1);
  1259.     }
  1260.  
  1261.  
  1262.     togglePingDisplay() {
  1263.       this.isPingVisible = !this.isPingVisible;
  1264.       this.updatePingVisibility();
  1265.     }
  1266.  
  1267.     toggleKillsDisplay() {
  1268.       this.isKillsVisible = !this.isKillsVisible;
  1269.       this.updateKillsVisibility();
  1270.     }
  1271.  
  1272.     getKills() {
  1273.       const killElement = document.querySelector(
  1274.         ".ui-player-kills.js-ui-player-kills",
  1275.       );
  1276.       if (killElement) {
  1277.         const kills = parseInt(killElement.textContent, 10);
  1278.         return isNaN(kills) ? 0 : kills;
  1279.       }
  1280.       return 0;
  1281.     }
  1282.  
  1283.     getRegionFromLocalStorage() {
  1284.       let config = localStorage.getItem("surviv_config");
  1285.       if (config) {
  1286.         let configObject = JSON.parse(config);
  1287.         return configObject.region;
  1288.       }
  1289.       return null;
  1290.     }
  1291.  
  1292.     startPingTest() {
  1293.       const currentUrl = window.location.href;
  1294.       const isSpecialUrl = /\/#\w+/.test(currentUrl);
  1295.  
  1296.       const teamSelectElement = document.getElementById("team-server-select");
  1297.       const mainSelectElement = document.getElementById("server-select-main");
  1298.  
  1299.       const region =
  1300.         isSpecialUrl && teamSelectElement
  1301.           ? teamSelectElement.value
  1302.           : mainSelectElement
  1303.             ? mainSelectElement.value
  1304.             : null;
  1305.  
  1306.       if (region && region !== this.currentServer) {
  1307.         this.currentServer = region;
  1308.         this.resetPing();
  1309.  
  1310.         let servers;
  1311.  
  1312.         if (window.location.hostname === 'resurviv.biz'){
  1313.             servers = [
  1314.               { region: "NA", url: "resurviv.biz:8001" },
  1315.               { region: "EU", url: "217.160.224.171:8001" },
  1316.             ];
  1317.         }else if (window.location.hostname === 'survev.io'){
  1318.             servers = [
  1319.                 { region: "NA", url: "usr.mathsiscoolfun.com:8001" },
  1320.                 { region: "EU", url: "eur.mathsiscoolfun.com:8001" },
  1321.                 { region: "Asia", url: "asr.mathsiscoolfun.com:8001" },
  1322.                 { region: "SA", url: "sa.mathsiscoolfun.com:8001" },
  1323.             ];
  1324.         }
  1325.  
  1326.  
  1327.         const selectedServer = servers.find(
  1328.           (server) => region.toUpperCase() === server.region.toUpperCase(),
  1329.         );
  1330.  
  1331.         if (selectedServer) {
  1332.           this.pingTest = new PingTest(selectedServer);
  1333.           this.pingTest.startPingTest();
  1334.         } else {
  1335.           this.resetPing();
  1336.         }
  1337.       }
  1338.     }
  1339.  
  1340.     resetPing() {
  1341.       if (this.pingTest && this.pingTest.test.ws) {
  1342.         this.pingTest.test.ws.close();
  1343.         this.pingTest.test.ws = null;
  1344.       }
  1345.       this.pingTest = null;
  1346.     }
  1347.  
  1348.  
  1349.     saveBackgroundToLocalStorage(url) {
  1350.       localStorage.setItem("lastBackgroundUrl", url);
  1351.     }
  1352.  
  1353.     saveBackgroundToLocalStorage(image) {
  1354.       if (typeof image === "string") {
  1355.         localStorage.setItem("lastBackgroundType", "url");
  1356.         localStorage.setItem("lastBackgroundValue", image);
  1357.       } else {
  1358.         localStorage.setItem("lastBackgroundType", "local");
  1359.         const reader = new FileReader();
  1360.         reader.onload = () => {
  1361.           localStorage.setItem("lastBackgroundValue", reader.result);
  1362.         };
  1363.         reader.readAsDataURL(image);
  1364.       }
  1365.     }
  1366.  
  1367.     loadBackgroundFromLocalStorage() {
  1368.       const backgroundType = localStorage.getItem("lastBackgroundType");
  1369.       const backgroundValue = localStorage.getItem("lastBackgroundValue");
  1370.  
  1371.       const backgroundElement = document.getElementById("background");
  1372.       if (backgroundElement && backgroundType && backgroundValue) {
  1373.         if (backgroundType === "url") {
  1374.           backgroundElement.style.backgroundImage = `url(${backgroundValue})`;
  1375.         } else if (backgroundType === "local") {
  1376.           backgroundElement.style.backgroundImage = `url(${backgroundValue})`;
  1377.         }
  1378.       }
  1379.     }
  1380.     loadLocalStorage() {
  1381.         const savedSettings = JSON.parse(localStorage.getItem("userSettings"));
  1382.         if (savedSettings) {
  1383.             this.isFpsVisible = savedSettings.isFpsVisible ?? this.isFpsVisible;
  1384.             this.isPingVisible = savedSettings.isPingVisible ?? this.isPingVisible;
  1385.             this.isKillsVisible = savedSettings.isKillsVisible ?? this.isKillsVisible;
  1386.             this.isClean = savedSettings.isClean ?? this.isClean;
  1387.         }
  1388.  
  1389.         this.updateKillsVisibility();
  1390.         this.updateFpsVisibility();
  1391.         this.updatePingVisibility();
  1392.     }
  1393.  
  1394.     updateHealthBars() {
  1395.       const healthBars = document.querySelectorAll("#ui-health-container");
  1396.       healthBars.forEach((container) => {
  1397.         const bar = container.querySelector("#ui-health-actual");
  1398.         if (bar) {
  1399.           const width = Math.round(parseFloat(bar.style.width));
  1400.           let percentageText = container.querySelector(".health-text");
  1401.  
  1402.           if (!percentageText) {
  1403.             percentageText = document.createElement("span");
  1404.             percentageText.classList.add("health-text");
  1405.             Object.assign(percentageText.style, {
  1406.               width: "100%",
  1407.               textAlign: "center",
  1408.               marginTop: "5px",
  1409.               color: "#333",
  1410.               fontSize: "20px",
  1411.               fontWeight: "bold",
  1412.               position: "absolute",
  1413.               zIndex: "10",
  1414.             });
  1415.             container.appendChild(percentageText);
  1416.           }
  1417.  
  1418.           percentageText.textContent = `${width}%`;
  1419.         }
  1420.       });
  1421.     }
  1422.  
  1423.     updateBoostBars() {
  1424.       const boostCounter = document.querySelector("#ui-boost-counter");
  1425.       if (boostCounter) {
  1426.         const boostBars = boostCounter.querySelectorAll(
  1427.           ".ui-boost-base .ui-bar-inner",
  1428.         );
  1429.  
  1430.         let totalBoost = 0;
  1431.         const weights = [25, 25, 40, 10];
  1432.  
  1433.         boostBars.forEach((bar, index) => {
  1434.           const width = parseFloat(bar.style.width);
  1435.           if (!isNaN(width)) {
  1436.             totalBoost += width * (weights[index] / 100);
  1437.           }
  1438.         });
  1439.  
  1440.         const averageBoost = Math.round(totalBoost);
  1441.         let boostDisplay = boostCounter.querySelector(".boost-display");
  1442.  
  1443.         if (!boostDisplay) {
  1444.           boostDisplay = document.createElement("div");
  1445.           boostDisplay.classList.add("boost-display");
  1446.           Object.assign(boostDisplay.style, {
  1447.             position: "absolute",
  1448.             bottom: "75px",
  1449.             right: "335px",
  1450.             color: "#FF901A",
  1451.             backgroundColor: "rgba(0, 0, 0, 0.4)",
  1452.             padding: "5px 10px",
  1453.             borderRadius: "5px",
  1454.             fontFamily: "Arial, sans-serif",
  1455.             fontSize: "14px",
  1456.             zIndex: "10",
  1457.             textAlign: "center",
  1458.           });
  1459.  
  1460.           boostCounter.appendChild(boostDisplay);
  1461.         }
  1462.  
  1463.         boostDisplay.textContent = `AD: ${averageBoost}%`;
  1464.       }
  1465.     }
  1466.  
  1467.     setupWeaponBorderHandler() {
  1468.         const weaponContainers = Array.from(
  1469.           document.getElementsByClassName("ui-weapon-switch"),
  1470.         );
  1471.         weaponContainers.forEach((container) => {
  1472.           if (container.id === "ui-weapon-id-4") {
  1473.             container.style.border = "3px solid #2f4032";
  1474.           } else {
  1475.             container.style.border = "3px solid #FFFFFF";
  1476.           }
  1477.         });
  1478.   
  1479.         const weaponNames = Array.from(
  1480.           document.getElementsByClassName("ui-weapon-name"),
  1481.         );
  1482.         weaponNames.forEach((weaponNameElement) => {
  1483.           const weaponContainer = weaponNameElement.closest(".ui-weapon-switch");
  1484.           const observer = new MutationObserver(() => {
  1485.             const weaponName = weaponNameElement.textContent.trim();
  1486.             let border = "#FFFFFF";
  1487.   
  1488.             switch (weaponName.toUpperCase()) { 
  1489.               //yellow
  1490.               case "CZ-3A1": case "G18C": case "M9": case "M93R": case "MAC-10": case "MP5": case "P30L": case "DUAL P30L": case "UMP9": case "VECTOR": case "VSS": case "FLAMETHROWER": border = "#FFAE00"; break;
  1491.               //blue 
  1492.               case "AK-47": case "OT-38": case "OTS-38": case "M39 EMR": case "DP-28": case "MOSIN-NAGANT": case "SCAR-H": case "SV-98": case "M1 GARAND": case "PKP PECHENEG": case "AN-94": case "BAR M1918": case "BLR 81": case "SVD-63": case "M134": case "GROZA": case "GROZA-S": border = "#007FFF"; break;
  1493.               //green
  1494.               case "FAMAS": case "M416": case "M249": case "QBB-97": case "MK 12 SPR": case "M4A1-S": case "SCOUT ELITE": case "L86A2": border = "#0f690d"; break;
  1495.               //red 
  1496.               case "M870": case "MP220": case "SAIGA-12": case "SPAS-12": case "USAS-12": case "SUPER 90": case "LASR GUN": case "M1100": border = "#FF0000"; break;
  1497.               //purple
  1498.               case "MODEL 94": case "PEACEMAKER": case "VECTOR (.45 ACP)": case "M1911": case "M1A1": border = "#800080"; break;
  1499.               //black
  1500.               case "DEAGLE 50": case "RAINBOW BLASTER": border = "#000000"; break;
  1501.               //olive
  1502.               case "AWM-S": case "MK 20 SSR": border = "#808000"; break; 
  1503.               //brown
  1504.               case "POTATO CANNON": case "SPUD GUN": border = "#A52A2A"; break;
  1505.               //other Guns
  1506.               case "FLARE GUN": border = "#FF4500"; break; case "M79": border = "#008080"; break; case "HEART CANNON": border = "#FFC0CB"; break; 
  1507.               default: border = "#FFFFFF"; break; }
  1508.   
  1509.             if (weaponContainer.id !== "ui-weapon-id-4") {
  1510.               weaponContainer.style.border = `3px solid ${border}`;
  1511.             }
  1512.           });
  1513.   
  1514.           observer.observe(weaponNameElement, {
  1515.             childList: true,
  1516.             characterData: true,
  1517.             subtree: true,
  1518.           });
  1519.         });
  1520.       }
  1521.  
  1522.     updateUiElements() {
  1523.       const currentUrl = window.location.href;
  1524.  
  1525.       const isSpecialUrl = /\/#\w+/.test(currentUrl);
  1526.  
  1527.       const playerOptions = document.getElementById("player-options");
  1528.       const teamMenuContents = document.getElementById("team-menu-contents");
  1529.       const startMenuContainer = document.querySelector(
  1530.         "#start-menu .play-button-container",
  1531.       );
  1532.  
  1533.       if (!playerOptions) return;
  1534.  
  1535.       if (
  1536.         isSpecialUrl &&
  1537.         teamMenuContents &&
  1538.         playerOptions.parentNode !== teamMenuContents
  1539.       ) {
  1540.         teamMenuContents.appendChild(playerOptions);
  1541.       } else if (
  1542.         !isSpecialUrl &&
  1543.         startMenuContainer &&
  1544.         playerOptions.parentNode !== startMenuContainer
  1545.       ) {
  1546.         const firstChild = startMenuContainer.firstChild;
  1547.         startMenuContainer.insertBefore(playerOptions, firstChild);
  1548.       }
  1549.       const teamMenu = document.getElementById("team-menu");
  1550.       if (teamMenu) {
  1551.         teamMenu.style.height = "355px";
  1552.       }
  1553.       const menuBlocks = document.querySelectorAll(".menu-block");
  1554.       menuBlocks.forEach((block) => {
  1555.         block.style.maxHeight = "355px";
  1556.       });
  1557.       const leftColumn = document.getElementById("left-column");
  1558.       const newsBlock = document.getElementById("news-block");
  1559.       //scalable?
  1560.     }
  1561.  
  1562.     updateCleanMode() {
  1563.         const leftColumn = document.getElementById("left-column");
  1564.         const newsBlock = document.getElementById("news-block");
  1565.  
  1566.         if (this.isClean) {
  1567.             if (leftColumn) leftColumn.style.display = "none";
  1568.             if (newsBlock) newsBlock.style.display = "none";
  1569.         } else {
  1570.             if (leftColumn) leftColumn.style.display = "block";
  1571.             if (newsBlock) newsBlock.style.display = "block";
  1572.         }
  1573.     }
  1574.  
  1575.     updateMenuButtonText() {
  1576.       const hideButton = document.getElementById("hideMenuButton");
  1577.       hideButton.textContent = this.isMenuVisible
  1578.         ? "Hide Menu [P]"
  1579.         : "Show Menu [P]";
  1580.     }
  1581.  
  1582.     setupKeyListeners() {
  1583.       document.addEventListener("keydown", (event) => {
  1584.         if (event.key.toLowerCase() === "p") {
  1585.           this.toggleMenuVisibility();
  1586.         }
  1587.       });
  1588.     }
  1589.     //menu
  1590.     initMenu() {
  1591.         const middleRow = document.querySelector("#start-row-top");
  1592.         Object.assign(middleRow.style, {
  1593.             display: "flex",
  1594.             flexDirection: "row",
  1595.         });
  1596.  
  1597.  
  1598.         const menu = document.createElement("div");
  1599.         menu.id = "KrityHack";
  1600.         Object.assign(menu.style, {
  1601.           backgroundColor: "rgba(0, 0, 0, 0.5)",
  1602.           padding: "15px",
  1603.           borderRadius: "10px",
  1604.           boxShadow: "0 4px 10px rgba(0, 0, 0, 0.3)",
  1605.           fontFamily: "Arial, sans-serif",
  1606.           fontSize: "18px",
  1607.           color: "#fff",
  1608.           maxWidth: "300px",
  1609.           height: "100%",
  1610.         //   maxHeight: "320px",
  1611.           overflowY: "auto",
  1612.         //   marginTop: "20px",
  1613.           marginRight: "30px",
  1614.           boxSizing: "border-box",
  1615.         });
  1616.  
  1617.       
  1618.         const title = document.createElement("h2");
  1619.         title.textContent = "Social networks";
  1620.         title.className = 'news-header';
  1621.         Object.assign(title.style, {
  1622.           margin: "0 0 10px",
  1623.           fontSize: "20px",
  1624.         });
  1625.         menu.append(title);
  1626.  
  1627.         const description = document.createElement("p");
  1628.         description.className = "news-paragraph";
  1629.         description.style.fontSize = "14px";
  1630.         description.innerHTML = `⭐ Star us on GitHub<br>📢 Join our Telegram group<br>🎮 Join our Discord server`
  1631.         menu.append(description);
  1632.       
  1633.         const createSocialLink = (text) => {
  1634.           const a = document.createElement("a");
  1635.           a.textContent = `${text}`;
  1636.           a.target = "_blank";
  1637.           Object.assign(a.style, {
  1638.             display: "block",
  1639.             border: "none",
  1640.             color: "#fff",
  1641.             padding: "10px",
  1642.             borderRadius: "5px",
  1643.             marginBottom: "10px",
  1644.             fontSize: "15px",
  1645.             lineHeight: "14px",
  1646.             cursor: "pointer",
  1647.             textAlign: "center",
  1648.             textDecoration: "none",
  1649.           });
  1650.           return a;
  1651.         };
  1652.       
  1653.         const githubLink = createSocialLink("");
  1654.         githubLink.style.backgroundColor = "#0c1117";
  1655.         githubLink.href = "https://github.com/Drino955/survev-krityhack";
  1656.         githubLink.innerHTML = `<i class="fa-brands fa-github"></i> KrityHack`;
  1657.         menu.append(githubLink);
  1658.         
  1659.         const telegramLink = createSocialLink("");
  1660.         telegramLink.style.backgroundColor = "#00a8e6";
  1661.         telegramLink.href = "https://t.me/krityteam";
  1662.         telegramLink.innerHTML = `<i class="fa-brands fa-telegram-plane"></i> KrityTeam`;
  1663.         menu.append(telegramLink);
  1664.  
  1665.         const discordLink = createSocialLink("");
  1666.         discordLink.style.backgroundColor = "#5865F2";
  1667.         discordLink.href = "https://discord.gg/wPuvEySg3E";
  1668.         discordLink.innerHTML = `<i class="fa-brands fa-discord"></i> [HACK] League of Hackers`;
  1669.         menu.append(discordLink);
  1670.  
  1671.         const additionalDescription = document.createElement("p");
  1672.         additionalDescription.className = "news-paragraph";
  1673.         additionalDescription.style.fontSize = "14px";
  1674.         additionalDescription.innerHTML = `Your support helps us develop the project and provide better updates!`
  1675.         menu.append(additionalDescription);
  1676.  
  1677.         const leftColumn = document.querySelector('#left-column');
  1678.         leftColumn.innerHTML = ``;
  1679.         leftColumn.style.marginTop = "10px";
  1680.         leftColumn.style.marginBottom = "27px";
  1681.         leftColumn.append(menu);
  1682.       
  1683.         this.menu = menu;
  1684.     }
  1685.  
  1686.     initRules() {
  1687.         const newsBlock = document.querySelector("#news-block");
  1688.         newsBlock.innerHTML = `
  1689. <h3 class="news-header">KrityHack v0.2.1</h3>
  1690. <div id="news-current">
  1691. <small class="news-date">January 13, 2025</small>
  1692.                       
  1693. <h2>How to use the cheat in the game 🚀</h2>
  1694. <p class="news-paragraph">After installing the cheat, you can use the following features and hotkeys:</p>
  1695.  
  1696. <h3>Hotkeys:</h3>
  1697. <ul>
  1698.     <li><strong>[B]</strong> - Toggle AimBot</li>
  1699.     <li><strong>[Z]</strong> - Toggle Zoom</li>
  1700.     <li><strong>[M]</strong> - Toggle Melee Attack</li>
  1701.     <li><strong>[Y]</strong> - Toggle SpinBot</li>
  1702.     <li><strong>[T]</strong> - Focus on enemy</li>
  1703. </ul>
  1704.  
  1705. <h3>Features:</h3>
  1706. <ul>
  1707.     <li>By clicking the middle mouse button, you can add a player to friends. AimBot will not target them, green lines will go to them, and their name will turn green.</li>
  1708.     <li><strong>AutoMelee:</strong> If the enemy is close enough (4 game coordinates), AutoMelee will automatically move towards and attack them when holding down the left mouse button. If you equip a melee weapon, AutoMelee will work at a distance of 8 game coordinates.</li>
  1709.     <li><strong>AutoSwitch:</strong> Quickly switch weapons to avoid cooldown after shooting.</li>
  1710.     <li><strong>BumpFire:</strong> Shoot without constant clicking.</li>
  1711.     <li>Some ESP features can be disabled by changing their values in the code:
  1712.         <pre>let laserDrawerEnabled = true;
  1713. let lineDrawerEnabled = true;
  1714. let nadeDrawerEnabled = true;
  1715.         </pre>
  1716.         Set them to <code>false</code> to disable.
  1717.     </li>
  1718.     <li>AimBot activates when holding down the left mouse button.</li>
  1719.     <li><strong>FocusedEnemy:</strong> Press <strong>[T]</strong> to focus on an enemy. AimBot will continuously target the focused enemy. Press <strong>[T]</strong> again to reset.</li>
  1720. </ul>
  1721.  
  1722. <h3>Recommendations:</h3>
  1723. <ul>
  1724.     <li>Play smart and don't rush headlong, as the cheat does not provide immortality.</li>
  1725.     <li>Use adrenaline to the max to heal and run fast.</li>
  1726.     <li>The map is color-coded: white circle - Mosin, gold container - SV98, etc.</li>
  1727. </ul>
  1728.  
  1729. <p class="news-paragraph">For more details, visit the <a href="https://github.com/Drino955/survev-krityhack">GitHub page</a> and join our <a href="https://t.me/krityteam">Telegram group</a> or <a href="https://discord.gg/wPuvEySg3E">Discord</a>.</p></div>`;
  1730.     
  1731.     
  1732.     }
  1733.  
  1734.     toggleMenuVisibility() {
  1735.       const isVisible = this.menu.style.display !== "none";
  1736.       this.menu.style.display = isVisible ? "none" : "block";
  1737.     }
  1738.  
  1739.     startUpdateLoop() {
  1740.       const now = performance.now();
  1741.       const delta = now - this.lastFrameTime;
  1742.  
  1743.       this.frameCount++;
  1744.  
  1745.       if (delta >= 1000) {
  1746.         this.fps = Math.round((this.frameCount * 1000) / delta);
  1747.         this.frameCount = 0;
  1748.         this.lastFrameTime = now;
  1749.  
  1750.         this.kills = this.getKills();
  1751.  
  1752.         if (this.isFpsVisible && this.fpsCounter) {
  1753.           this.fpsCounter.textContent = `FPS: ${this.fps}`;
  1754.         }
  1755.  
  1756.         if (this.isKillsVisible && this.killsCounter) {
  1757.           this.killsCounter.textContent = `Kills: ${this.kills}`;
  1758.         }
  1759.  
  1760.         if (this.isPingVisible && this.pingCounter && this.pingTest) {
  1761.           const result = this.pingTest.getPingResult();
  1762.           this.pingCounter.textContent = `PING: ${result.ping} ms`;
  1763.         }
  1764.       }
  1765.  
  1766.       this.startPingTest();
  1767.       this.animationFrameCallback(() => this.startUpdateLoop());
  1768.       this.updateUiElements();
  1769.       this.updateCleanMode();
  1770.       this.updateBoostBars();
  1771.       this.updateHealthBars();
  1772.     }
  1773.     
  1774.   }
  1775.  
  1776. window.PingTest = class PingTest {
  1777.     constructor(selectedServer) {
  1778.       this.ptcDataBuf = new ArrayBuffer(1);
  1779.       this.test = {
  1780.         region: selectedServer.region,
  1781.         url: `wss://${selectedServer.url}/ptc`,
  1782.         ping: 9999,
  1783.         ws: null,
  1784.         sendTime: 0,
  1785.         retryCount: 0,
  1786.       };
  1787.     }
  1788.  
  1789.     startPingTest() {
  1790.       if (!this.test.ws) {
  1791.         const ws = new WebSocket(this.test.url);
  1792.         ws.binaryType = "arraybuffer";
  1793.  
  1794.         ws.onopen = () => {
  1795.           this.sendPing();
  1796.           this.test.retryCount = 0;
  1797.         };
  1798.  
  1799.         ws.onmessage = () => {
  1800.           const elapsed = (Date.now() - this.test.sendTime) / 1e3;
  1801.           this.test.ping = Math.round(elapsed * 1000);
  1802.           this.test.retryCount = 0;
  1803.           setTimeout(() => this.sendPing(), 200);
  1804.         };
  1805.  
  1806.         ws.onerror = () => {
  1807.           this.test.ping = "Error";
  1808.           this.test.retryCount++;
  1809.           if (this.test.retryCount < 5) {
  1810.             setTimeout(() => this.startPingTest(), 2000);
  1811.           } else {
  1812.             this.test.ws.close();
  1813.             this.test.ws = null;
  1814.           }
  1815.         };
  1816.  
  1817.         ws.onclose = () => {
  1818.           this.test.ws = null;
  1819.         };
  1820.  
  1821.         this.test.ws = ws;
  1822.       }
  1823.     }
  1824.  
  1825.     sendPing() {
  1826.       if (this.test.ws.readyState === WebSocket.OPEN) {
  1827.         this.test.sendTime = Date.now();
  1828.         this.test.ws.send(this.ptcDataBuf);
  1829.       }
  1830.     }
  1831.  
  1832.     getPingResult() {
  1833.       return {
  1834.         region: this.test.region,
  1835.         ping: this.test.ping,
  1836.       };
  1837.     }
  1838. }
  1839.  
  1840.  
  1841. console.log('Script injected')