☰

Survev-KrityHack

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

2025-01-14 يوللانغان نەشرى. ئەڭ يېڭى نەشرىنى كۆرۈش.

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