☰

Greasy Fork is available in English.

Chess.com UltraX bot with Panel

Enhances your Chess.com experience with move suggestions, UI enhancements, and customizable features. Credits to GoodtimeswithEno for the initial move highlighting and basic chess engine implementation.

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

  1. // ==UserScript==
  2. // additional copyright/license info:
  3. //© All Rights Reserved
  4. //
  5. //Chess.com Enhanced Experience © 2024 by Akashdeep
  6. //
  7. // ==UserScript
  8. // @name         Chess.com UltraX bot with Panel
  9. // @namespace    Akashdeep
  10. // @version      1.0.0.5
  11. // @description  Enhances your Chess.com experience with move suggestions, UI enhancements, and customizable features.  Credits to GoodtimeswithEno for the initial move highlighting and basic chess engine implementation.
  12. // @author       Akashdeep
  13. // @license      Chess.com Enhanced Experience © 2024 by Akashdeep, © All Rights Reserved
  14. // @match       https://www.chess.com/play/*
  15. // @match       https://www.chess.com/game/*
  16. // @match       https://www.chess.com/puzzles/*
  17. // @match       https://www.chess.com/*
  18. // @icon         data:image/gif;base64,R0lGODlhAQABAIABAP///wAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==
  19. // @grant       GM_getValue
  20. // @grant       GM_setValue
  21. // @grant       GM_xmlhttpRequest
  22. // @grant       GM_getResourceText
  23. // @grant       GM_registerMenuCommand
  24. // @resource    stockfish.js        https://cdnjs.cloudflare.com/ajax/libs/stockfish.js/10.0.2/stockfish.js
  25. // @require     https://greatest.deepsurf.us/scripts/445697/code/index.js
  26. // @require     https://code.jquery.com/jquery-3.6.0.min.js
  27. // @run-at      document-start
  28. // @liscense MIT
  29.  
  30. // @downloadURL
  31. // @updateURL
  32. // ==/UserScript==
  33.  
  34. //Don't touch anything below unless you know what your doing!
  35.  
  36. const currentVersion = '1.0.0.5'; // Sets the current version
  37.  
  38. function main() {
  39.  
  40.     var stockfishObjectURL;
  41.     var engine = document.engine = {};
  42.     var myVars = document.myVars = {};
  43.     myVars.autoMovePiece = false;
  44.     myVars.autoRun = false;
  45.     myVars.delay = 0.1;
  46.     var myFunctions = document.myFunctions = {};
  47.  
  48.     myVars.playStyle = {
  49.         aggressive: Math.random() * 0.5 + 0.3,  // 0.3-0.8 tendency for aggressive moves
  50.         defensive: Math.random() * 0.5 + 0.3,   // 0.3-0.8 tendency for defensive moves
  51.         tactical: Math.random() * 0.6 + 0.2,    // 0.2-0.8 tendency for tactical moves
  52.         positional: Math.random() * 0.6 + 0.2   // 0.2-0.8 tendency for positional moves
  53.     };
  54.  
  55.     myVars.preferredOpenings = [
  56.         "e4", "d4", "c4", "Nf3"   // Just examples, could be expanded
  57.     ].sort(() => Math.random() - 0.5); // Randomize the order
  58.  
  59.     myVars.playerFingerprint = GM_getValue('playerFingerprint', {
  60.         favoredPieces: Math.random() < 0.5 ? 'knights' : 'bishops',
  61.         openingTempo: Math.random() * 0.5 + 0.5, // 0.5-1.0 opening move speed
  62.         tacticalAwareness: Math.random() * 0.4 + 0.6, // 0.6-1.0 tactical vision
  63.         exchangeThreshold: Math.random() * 0.3 + 0.1, // When to accept exchanges
  64.         attackingStyle: ['kingside', 'queenside', 'central'][Math.floor(Math.random() * 3)]
  65.     });
  66.     // Save on first run
  67.     if (!GM_getValue('playerFingerprint')) {
  68.         GM_setValue('playerFingerprint', myVars.playerFingerprint);
  69.     }
  70.  
  71.     // Add to myVars initialization
  72.     myVars.tacticalProfile = GM_getValue('tacticalProfile', {
  73.         strengths: [
  74.             getRandomTacticalStrength(),
  75.             getRandomTacticalStrength()
  76.         ],
  77.         weaknesses: [
  78.             getRandomTacticalWeakness(),
  79.             getRandomTacticalWeakness()
  80.         ]
  81.     });
  82.  
  83.     // Save on first run
  84.     if (!GM_getValue('tacticalProfile')) {
  85.         GM_setValue('tacticalProfile', myVars.tacticalProfile);
  86.     }
  87.  
  88.     function getRandomTacticalStrength() {
  89.         const strengths = [
  90.             'fork', 'pin', 'skewer', 'discovery', 'zwischenzug',
  91.             'removing-defender', 'attraction'
  92.         ];
  93.         return strengths[Math.floor(Math.random() * strengths.length)];
  94.     }
  95.  
  96.     function getRandomTacticalWeakness() {
  97.         const weaknesses = [
  98.             'long-calculation', 'quiet-moves', 'backward-moves',
  99.             'zugzwang', 'prophylaxis', 'piece-coordination'
  100.         ];
  101.         return weaknesses[Math.floor(Math.random() * weaknesses.length)];
  102.     }
  103.  
  104.     stop_b = stop_w = 0;
  105.     s_br = s_br2 = s_wr = s_wr2 = 0;
  106.     obs = "";
  107.     myFunctions.rescan = function(lev) {
  108.         var ari = $("chess-board")
  109.         .find(".piece")
  110.         .map(function() {
  111.             return this.className;
  112.         })
  113.         .get();
  114.         jack = ari.map(f => f.substring(f.indexOf(' ') + 1));
  115.         function removeWord(arr, word) {
  116.             for (var i = 0; i < arr.length; i++) {
  117.                 arr[i] = arr[i].replace(word, '');
  118.             }
  119.         }
  120.         removeWord(ari, 'square-');
  121.         jack = ari.map(f => f.substring(f.indexOf(' ') + 1));
  122.         for (var i = 0; i < jack.length; i++) {
  123.             jack[i] = jack[i].replace('br', 'r')
  124.                 .replace('bn', 'n')
  125.                 .replace('bb', 'b')
  126.                 .replace('bq', 'q')
  127.                 .replace('bk', 'k')
  128.                 .replace('bb', 'b')
  129.                 .replace('bn', 'n')
  130.                 .replace('br', 'r')
  131.                 .replace('bp', 'p')
  132.                 .replace('wp', 'P')
  133.                 .replace('wr', 'R')
  134.                 .replace('wn', 'N')
  135.                 .replace('wb', 'B')
  136.                 .replace('br', 'R')
  137.                 .replace('wn', 'N')
  138.                 .replace('wb', 'B')
  139.                 .replace('wq', 'Q')
  140.                 .replace('wk', 'K')
  141.                 .replace('wb', 'B')
  142.         }
  143.         str2 = "";
  144.         var count = 0,
  145.             str = "";
  146.         for (var j = 8; j > 0; j--) {
  147.             for (var i = 1; i < 9; i++) {
  148.                 (str = (jack.find(el => el.includes([i] + [j])))) ? str = str.replace(/[^a-zA-Z]+/g, ''): str = "";
  149.                 if (str == "") {
  150.                     count++;
  151.                     str = count.toString();
  152.                     if (!isNaN(str2.charAt(str2.length - 1))) str2 = str2.slice(0, -1);
  153.                     else {
  154.                         count = 1;
  155.                         str = count.toString()
  156.                     }
  157.                 }
  158.                 str2 += str;
  159.                 if (i == 8) {
  160.                     count = 0;
  161.                     str2 += "/";
  162.                 }
  163.             }
  164.         }
  165.         str2 = str2.slice(0, -1);
  166.         //str2=str2+" KQkq - 0"
  167.         color = "";
  168.         wk = wq = bk = bq = "0";
  169.         const move = $('vertical-move-list')
  170.         .children();
  171.         if (move.length < 2) {
  172.             stop_b = stop_w = s_br = s_br2 = s_wr = s_wr2 = 0;
  173.         }
  174.         if (stop_b != 1) {
  175.             if (move.find(".black.node:contains('K')")
  176.                 .length) {
  177.                 bk = "";
  178.                 bq = "";
  179.                 stop_b = 1;
  180.                 console.log('debug secb');
  181.             }
  182.         } else {
  183.             bq = "";
  184.             bk = "";
  185.         }
  186.         if (stop_b != 1)(bk = (move.find(".black.node:contains('O-O'):not(:contains('O-O-O'))")
  187.                                .length) ? "" : "k") ? (bq = (move.find(".black.node:contains('O-O-O')")
  188.                                                              .length) ? bk = "" : "q") : bq = "";
  189.         if (s_br != 1) {
  190.             if (move.find(".black.node:contains('R')")
  191.                 .text()
  192.                 .match('[abcd]+')) {
  193.                 bq = "";
  194.                 s_br = 1
  195.             }
  196.         } else bq = "";
  197.         if (s_br2 != 1) {
  198.             if (move.find(".black.node:contains('R')")
  199.                 .text()
  200.                 .match('[hgf]+')) {
  201.                 bk = "";
  202.                 s_br2 = 1
  203.             }
  204.         } else bk = "";
  205.         if (stop_b == 0) {
  206.             if (s_br == 0)
  207.                 if (move.find(".white.node:contains('xa8')")
  208.                     .length > 0) {
  209.                     bq = "";
  210.                     s_br = 1;
  211.                     console.log('debug b castle_r');
  212.                 }
  213.             if (s_br2 == 0)
  214.                 if (move.find(".white.node:contains('xh8')")
  215.                     .length > 0) {
  216.                     bk = "";
  217.                     s_br2 = 1;
  218.                     console.log('debug b castle_l');
  219.                 }
  220.         }
  221.         if (stop_w != 1) {
  222.             if (move.find(".white.node:contains('K')")
  223.                 .length) {
  224.                 wk = "";
  225.                 wq = "";
  226.                 stop_w = 1;
  227.                 console.log('debug secw');
  228.             }
  229.         } else {
  230.             wq = "";
  231.             wk = "";
  232.         }
  233.         if (stop_w != 1)(wk = (move.find(".white.node:contains('O-O'):not(:contains('O-O-O'))")
  234.                                .length) ? "" : "K") ? (wq = (move.find(".white.node:contains('O-O-O')")
  235.                                                              .length) ? wk = "" : "Q") : wq = "";
  236.         if (s_wr != 1) {
  237.             if (move.find(".white.node:contains('R')")
  238.                 .text()
  239.                 .match('[abcd]+')) {
  240.                 wq = "";
  241.                 s_wr = 1
  242.             }
  243.         } else wq = "";
  244.         if (s_wr2 != 1) {
  245.             if (move.find(".white.node:contains('R')")
  246.                 .text()
  247.                 .match('[hgf]+')) {
  248.                 wk = "";
  249.                 s_wr2 = 1
  250.             }
  251.         } else wk = "";
  252.         if (stop_w == 0) {
  253.             if (s_wr == 0)
  254.                 if (move.find(".black.node:contains('xa1')")
  255.                     .length > 0) {
  256.                     wq = "";
  257.                     s_wr = 1;
  258.                     console.log('debug w castle_l');
  259.                 }
  260.             if (s_wr2 == 0)
  261.                 if (move.find(".black.node:contains('xh1')")
  262.                     .length > 0) {
  263.                     wk = "";
  264.                     s_wr2 = 1;
  265.                     console.log('debug w castle_r');
  266.                 }
  267.         }
  268.         if ($('.coordinates')
  269.             .children()
  270.             .first()
  271.             .text() == 1) {
  272.             str2 = str2 + " b " + wk + wq + bk + bq;
  273.             color = "white";
  274.         } else {
  275.             str2 = str2 + " w " + wk + wq + bk + bq;
  276.             color = "black";
  277.         }
  278.         //console.log(str2);
  279.         return str2;
  280.     }
  281.     myFunctions.color = function(dat){
  282.         response = dat;
  283.         var res1 = response.substring(0, 2);
  284.         var res2 = response.substring(2, 4);
  285.  
  286.         // Check if automove is enabled and make the move
  287.         if(myVars.autoMove === true){
  288.             console.log(`Auto move enabled, moving from ${res1} to ${res2}`);
  289.             myFunctions.movePiece(res1, res2);
  290.         } else {
  291.             console.log(`Auto move disabled, highlighting ${res1} to ${res2}`);
  292.         }
  293.         isThinking = false;
  294.  
  295.         res1 = res1.replace(/^a/, "1")
  296.             .replace(/^b/, "2")
  297.             .replace(/^c/, "3")
  298.             .replace(/^d/, "4")
  299.             .replace(/^e/, "5")
  300.             .replace(/^f/, "6")
  301.             .replace(/^g/, "7")
  302.             .replace(/^h/, "8");
  303.         res2 = res2.replace(/^a/, "1")
  304.             .replace(/^b/, "2")
  305.             .replace(/^c/, "3")
  306.             .replace(/^d/, "4")
  307.             .replace(/^e/, "5")
  308.             .replace(/^f/, "6")
  309.             .replace(/^g/, "7")
  310.             .replace(/^h/, "8");
  311.  
  312.         // Use custom highlight color if available
  313.         const highlightColor = myVars.highlightColor || 'rgb(235, 97, 80)';
  314.  
  315.         $(board.nodeName)
  316.             .prepend(`<div class="highlight square-${res2} bro" style="background-color: ${highlightColor}; opacity: 0.71;" data-test-element="highlight"></div>`)
  317.             .children(':first')
  318.             .delay(1800)
  319.             .queue(function() {
  320.             $(this)
  321.                 .remove();
  322.         });
  323.         $(board.nodeName)
  324.             .prepend(`<div class="highlight square-${res1} bro" style="background-color: ${highlightColor}; opacity: 0.71;" data-test-element="highlight"></div>`)
  325.             .children(':first')
  326.             .delay(1800)
  327.             .queue(function() {
  328.             $(this)
  329.                 .remove();
  330.         });
  331.     }
  332.  
  333.     myFunctions.movePiece = function(from, to) {
  334.         // Check if the move is legal before attempting to make it
  335.         let isLegalMove = false;
  336.         let moveObject = null;
  337.         
  338.         for (let each = 0; each < board.game.getLegalMoves().length; each++) {
  339.             if (board.game.getLegalMoves()[each].from === from && 
  340.                 board.game.getLegalMoves()[each].to === to) {
  341.                 isLegalMove = true;
  342.                 moveObject = board.game.getLegalMoves()[each];
  343.                 break;
  344.             }
  345.         }
  346.         
  347.         if (!isLegalMove) {
  348.             console.log(`Attempted illegal move: ${from} to ${to}`);
  349.             return;
  350.         }
  351.         
  352.         // Add a small delay before making the move to simulate human reaction time
  353.         setTimeout(() => {
  354.             try {
  355.                 // Make the actual move
  356.                 board.game.move({
  357.                     ...moveObject,
  358.                     promotion: moveObject.promotion || 'q', // Default to queen for simplicity
  359.                     animate: true,
  360.                     userGenerated: true
  361.                 });
  362.                 console.log(`Successfully moved from ${from} to ${to}`);
  363.             } catch (error) {
  364.                 console.error("Error making move:", error);
  365.             }
  366.         }, 100 + Math.random() * 300); // Small random delay to appear more human-like
  367.     }
  368.  
  369.     // Replace simple movement simulation with this more advanced version
  370.     function simulateNaturalMouseMovement(from, to, callback) {
  371.         // Convert chess coordinates to screen positions
  372.         const fromPos = getSquarePosition(from);
  373.         const toPos = getSquarePosition(to);
  374.  
  375.         // Create a bezier curve path with a slight variance
  376.         const controlPoint1 = {
  377.             x: fromPos.x + (toPos.x - fromPos.x) * 0.3 + (Math.random() * 40 - 20),
  378.             y: fromPos.y + (toPos.y - fromPos.y) * 0.1 + (Math.random() * 40 - 20)
  379.         };
  380.  
  381.         const controlPoint2 = {
  382.             x: fromPos.x + (toPos.x - fromPos.x) * 0.7 + (Math.random() * 40 - 20),
  383.             y: fromPos.y + (toPos.y - fromPos.y) * 0.9 + (Math.random() * 40 - 20)
  384.         };
  385.  
  386.         // Calculate movement duration based on distance
  387.         const distance = Math.sqrt(Math.pow(toPos.x - fromPos.x, 2) + Math.pow(toPos.y - fromPos.y, 2));
  388.         const baseDuration = 300 + Math.random() * 400;
  389.         const movementDuration = baseDuration + distance * (0.5 + Math.random() * 0.5);
  390.  
  391.         // Create array of points along path
  392.         const steps = 15 + Math.floor(distance / 30);
  393.         const points = [];
  394.  
  395.         for (let i = 0; i <= steps; i++) {
  396.             const t = i / steps;
  397.             points.push(getBezierPoint(t, fromPos, controlPoint1, controlPoint2, toPos));
  398.         }
  399.  
  400.         // Execute the movement with variable speed
  401.         executeMouseMovement(points, 0, movementDuration / steps, callback);
  402.     }
  403.  
  404.     // Add these functions for more realistic timing
  405.     function calculateMoveComplexity(from, to) {
  406.         // Approximate complexity based on piece type, capture, check, etc.
  407.         // Returns a value between 0 (simple) and 1 (complex)
  408.         return Math.random() * 0.7 + 0.3; // Placeholder implementation
  409.     }
  410.  
  411.     function calculateHumanLikeDelay(complexity) {
  412.         // More complex positions take longer to think about
  413.         const baseDelay = 500; // Base delay in ms
  414.         const complexityFactor = 2500; // Max additional delay for complex positions
  415.         return baseDelay + (complexity * complexityFactor * Math.random());
  416.     }
  417.  
  418.     function getRandomThinkingDelay() {
  419.         // Humans don't immediately start calculating
  420.         return 300 + Math.random() * 700;
  421.     }
  422.  
  423.     function parser(e) {
  424.         if(e.data.includes('bestmove')) {
  425.             const bestMove = e.data.split(' ')[1];
  426.             
  427.             // Extract multiple moves from engine analysis if available
  428.             let alternativeMoves = [bestMove];
  429.             try {
  430.                 if (e.data.includes('pv')) {
  431.                     // Try to extract alternative moves from multiPV or previous info lines
  432.                     const lines = e.data.split('\n')
  433.                         .filter(line => line.includes(' pv '))
  434.                         .map(line => {
  435.                             const pvIndex = line.indexOf(' pv ');
  436.                             return line.substring(pvIndex + 4).split(' ')[0];
  437.                         });
  438.                     
  439.                     if (lines.length > 1) {
  440.                         alternativeMoves = lines;
  441.                     }
  442.                 }
  443.             } catch (error) {
  444.                 console.log("Error extracting alternative moves", error);
  445.             }
  446.             
  447.             // Decide whether to use best move or an alternative
  448.             let moveToPlay = bestMove;
  449.             const currentDepth = lastValue;
  450.             
  451.             // For higher depths, sometimes choose alternative moves
  452.             if (currentDepth >= 15 && alternativeMoves.length > 1 && Math.random() < 0.35) {
  453.                 // Select a random move from top 5 (or fewer if not available)
  454.                 const maxIndex = Math.min(5, alternativeMoves.length);
  455.                 const randomIndex = Math.floor(Math.random() * (maxIndex - 1)) + 1; // Skip index 0 (best move)
  456.                 moveToPlay = alternativeMoves[randomIndex] || bestMove;
  457.                 console.log(`Using alternative move ${moveToPlay} instead of best move ${bestMove}`);
  458.             } else if (Math.random() < getBlunderProbability()) {
  459.                 // Sometimes make a "human-like" suboptimal move
  460.                 moveToPlay = generateHumanLikeMove(bestMove, e.data);
  461.                 console.log(`Using human-like move ${moveToPlay} instead of best move ${bestMove}`);
  462.             }
  463.             
  464.             myFunctions.color(moveToPlay);
  465.             isThinking = false;
  466.         }
  467.     }
  468.  
  469.     function getBlunderProbability() {
  470.         // Use custom blunder rate from slider if available
  471.         const userBlunderRate = myVars.blunderRate !== undefined ? myVars.blunderRate : 0.05;
  472.  
  473.         // Make blunder probability vary based on multiple factors
  474.         const gamePhase = estimateGamePhase();
  475.         const timeRemaining = estimateTimeRemaining();
  476.         const complexity = estimatePositionComplexity();
  477.  
  478.         // Base probability comes from user settings
  479.         let baseProb = userBlunderRate;
  480.  
  481.         // More likely to blunder in time pressure
  482.         if (timeRemaining < 30) {
  483.             baseProb += 0.1 * (1 - (timeRemaining / 30));
  484.         }
  485.  
  486.         // More likely to blunder in complex positions
  487.         if (complexity > 0.6) {
  488.             baseProb += 0.05 * (complexity - 0.6) * 2;
  489.         }
  490.  
  491.         // More likely to blunder in the endgame when tired
  492.         if (gamePhase > 30) {
  493.             baseProb += 0.03 * ((gamePhase - 30) / 10);
  494.         }
  495.  
  496.         // Add randomness to make it unpredictable
  497.         return Math.min(0.4, baseProb * (0.7 + Math.random() * 0.6));
  498.     }
  499.  
  500.     function estimateGamePhase() {
  501.         // Estimate how far the game has progressed (0-40 approx)
  502.         try {
  503.             const moveList = $('vertical-move-list').children().length;
  504.             return moveList / 2; // Rough estimate of move number
  505.         } catch (e) {
  506.             return 15; // Default to middle game
  507.         }
  508.     }
  509.  
  510.     function estimateTimeRemaining() {
  511.     // Try to get the clock time if available
  512.     try {
  513.         const clockEl = document.querySelector('.clock-component');
  514.         if (clockEl) {
  515.             const timeText = clockEl.textContent;
  516.             if (timeText.includes(':')) {
  517.                 const parts = timeText.split(':');
  518.                 if (parts.length === 2) {
  519.                     const minutes = parseInt(parts[0]);
  520.                     const seconds = parseInt(parts[1]);
  521.                     return minutes * 60 + seconds;
  522.                 }
  523.             } else {
  524.                 // Handle single number format (e.g., just seconds)
  525.                 return parseInt(timeText);
  526.             }
  527.         }
  528.         
  529.         // Try alternative clock selectors
  530.         const altClockEl = document.querySelector('.clock-time-monospace') || 
  531.                           document.querySelector('.clock-time') ||
  532.                           document.querySelector('[data-cy="clock-time"]');
  533.         if (altClockEl) {
  534.             const timeText = altClockEl.textContent;
  535.             if (timeText.includes(':')) {
  536.                 const parts = timeText.split(':');
  537.                 if (parts.length === 2) {
  538.                     const minutes = parseInt(parts[0]);
  539.                     const seconds = parseInt(parts[1]);
  540.                     return minutes * 60 + seconds;
  541.                 }
  542.             } else {
  543.                 return parseInt(timeText);
  544.             }
  545.         }
  546.     } catch (e) {
  547.         console.log("Error getting time remaining:", e);
  548.     }
  549.  
  550.     // Default value if clock can't be read
  551.     return 180; // 3 minutes as default
  552. }
  553.  
  554.     function estimatePositionComplexity() {
  555.         // Calculate a complexity score between 0-1
  556.         // This would ideally analyze the position for tactical elements
  557.         return Math.random() * 0.8 + 0.2; // Placeholder
  558.     }
  559.  
  560.     function generateHumanLikeMove(bestMove, engineData) {
  561.         // Significantly enhance the human-like behavior
  562.         // Sometimes choose 2nd, 3rd, or even 4th best moves
  563.         if (engineData.includes('pv') && Math.random() < 0.4) {
  564.             try {
  565.                 // Extract multiple lines from engine analysis
  566.                 const lines = engineData.split('\n')
  567.                         .filter(line => line.includes(' pv '))
  568.                         .map(line => {
  569.                             const pvIndex = line.indexOf(' pv ');
  570.                             return line.substring(pvIndex + 4).split(' ')[0];
  571.                         });
  572.                     
  573.                     if (lines.length > 1) {
  574.                     // Weight moves by their quality (prefer better moves, but sometimes choose worse ones)
  575.                     const moveIndex = Math.floor(Math.pow(Math.random(), 2.5) * Math.min(lines.length, 4));
  576.                     return lines[moveIndex] || bestMove;
  577.                 }
  578.             } catch (e) {
  579.                 console.log("Error extracting alternative moves", e);
  580.             }
  581.         }
  582.  
  583.         // Occasionally make a typical human error based on common patterns
  584.         if (Math.random() < 0.15) {
  585.             // Approximate a plausible human move (e.g., moving to adjacent square)
  586.             const fromSquare = bestMove.substring(0, 2);
  587.             const toSquare = bestMove.substring(2, 4);
  588.  
  589.             // Simple adjustment - occasionally play a shorter move (undershoot)
  590.             if (Math.random() < 0.7) {
  591.                 const files = "abcdefgh";
  592.                 const ranks = "12345678";
  593.                 const fromFile = fromSquare.charAt(0);
  594.                 const fromRank = fromSquare.charAt(1);
  595.                 const toFile = toSquare.charAt(0);
  596.                 const toRank = toSquare.charAt(1);
  597.  
  598.                 // Calculate direction
  599.                 const fileDiff = files.indexOf(toFile) - files.indexOf(fromFile);
  600.                 const rankDiff = ranks.indexOf(toRank) - ranks.indexOf(fromRank);
  601.  
  602.                 // Sometimes undershoot by one square
  603.                 if (Math.abs(fileDiff) > 1 || Math.abs(rankDiff) > 1) {
  604.                     const newToFile = files[files.indexOf(fromFile) + (fileDiff > 0 ? Math.max(1, fileDiff-1) : Math.min(-1, fileDiff+1))];
  605.                     const newToRank = ranks[ranks.indexOf(fromRank) + (rankDiff > 0 ? Math.max(1, rankDiff-1) : Math.min(-1, rankDiff+1))];
  606.  
  607.                     // Check if the new square is valid
  608.                     if (newToFile && newToRank) {
  609.                         const alternativeMove = fromSquare + newToFile + newToRank;
  610.                         // Verify this is a legal move before returning
  611.                         for (let each=0; each<board.game.getLegalMoves().length; each++) {
  612.                             if (board.game.getLegalMoves()[each].from === fromSquare &&
  613.                                 board.game.getLegalMoves()[each].to === newToFile + newToRank) {
  614.                                 return alternativeMove;
  615.                             }
  616.                         }
  617.                     }
  618.                 }
  619.             }
  620.         }
  621.  
  622.         return bestMove;
  623.     }
  624.  
  625.     myFunctions.reloadChessEngine = function() {
  626.         console.log(`Reloading the chess engine!`);
  627.  
  628.         engine.engine.terminate();
  629.             isThinking = false;
  630.         myFunctions.loadChessEngine();
  631.     }
  632.  
  633.     myFunctions.loadChessEngine = function() {
  634.         if(!stockfishObjectURL) {
  635.             stockfishObjectURL = URL.createObjectURL(new Blob([GM_getResourceText('stockfish.js')], {type: 'application/javascript'}));
  636.         }
  637.         console.log(stockfishObjectURL);
  638.         if(stockfishObjectURL) {
  639.             engine.engine = new Worker(stockfishObjectURL);
  640.  
  641.             engine.engine.onmessage = e => {
  642.                 parser(e);
  643.             };
  644.             engine.engine.onerror = e => {
  645.                 console.log("Worker Error: "+e);
  646.             };
  647.  
  648.             engine.engine.postMessage('ucinewgame');
  649.         }
  650.         console.log('loaded chess engine');
  651.     }
  652.  
  653.     var lastValue = 11;
  654.  
  655.  
  656.     myFunctions.runChessEngine = function(depth) {
  657.     // Get time-adjusted depth
  658.     var adjustedDepth = getAdjustedDepth();
  659.     
  660.     // Get position type
  661.     var fen = board.game.getFEN();
  662.     var positionType = analyzePositionType(fen);
  663.     
  664.     // Log the depth adjustment
  665.     console.log(`Original depth: ${depth}, Adjusted for time/position: ${adjustedDepth}`);
  666.     
  667.     engine.engine.postMessage(`position fen ${fen}`);
  668.     console.log('updated: ' + `position fen ${fen}`);
  669.     isThinking = true;
  670.     
  671.     // Use multipv for alternative moves when depth is high
  672.     if (depth >= 15) {
  673.         engine.engine.postMessage(`setoption name MultiPV value 5`);
  674.     } else {
  675.         engine.engine.postMessage(`setoption name MultiPV value 1`);
  676.     }
  677.     
  678.     engine.engine.postMessage(`go depth ${adjustedDepth}`);
  679.     lastValue = depth; // Keep original depth for UI display
  680. }
  681.  
  682.     function analyzePositionType(fen) {
  683.         // Determine position type: opening, middlegame, endgame, tactical
  684.         const piecesCount = fen.split(' ')[0].match(/[pnbrqkPNBRQK]/g).length;
  685.  
  686.         if (piecesCount > 25) return 'opening';
  687.         if (piecesCount < 12) return 'endgame';
  688.         return 'middlegame';
  689.     }
  690.  
  691.     function adjustDepthByPosition(requestedDepth, positionType) {
  692.         // Humans play more accurately in different phases
  693.         if (positionType === 'opening' && Math.random() < 0.7) {
  694.             // In openings, humans often play memorized moves
  695.             return requestedDepth + Math.floor(Math.random() * 3);
  696.         } else if (positionType === 'endgame' && Math.random() < 0.5) {
  697.             // In endgames, calculation may be more/less precise
  698.             return requestedDepth + (Math.random() < 0.5 ? -1 : 1);
  699.         }
  700.  
  701.         // Occasionally randomize depth slightly
  702.         return Math.max(1, requestedDepth + (Math.random() < 0.3 ? Math.floor(Math.random() * 3) - 1 : 0));
  703.     }
  704.  
  705.     myFunctions.autoRun = function(lstValue){
  706.         if(board.game.getTurn() == board.game.getPlayingAs()){
  707.             myFunctions.runChessEngine(lstValue);
  708.         }
  709.     }
  710.  
  711.     document.onkeydown = function(e) {
  712.         switch (e.keyCode) {
  713.             case 81:
  714.                 myFunctions.runChessEngine(1);
  715.                 break;
  716.             case 87:
  717.                 myFunctions.runChessEngine(2);
  718.                 break;
  719.             case 69:
  720.                 myFunctions.runChessEngine(3);
  721.                 break;
  722.             case 82:
  723.                 myFunctions.runChessEngine(4);
  724.                 break;
  725.             case 84:
  726.                 myFunctions.runChessEngine(5);
  727.                 break;
  728.             case 89:
  729.                 myFunctions.runChessEngine(6);
  730.                 break;
  731.             case 85:
  732.                 myFunctions.runChessEngine(7);
  733.                 break;
  734.             case 73:
  735.                 myFunctions.runChessEngine(8);
  736.                 break;
  737.             case 79:
  738.                 myFunctions.runChessEngine(9);
  739.                 break;
  740.             case 80:
  741.                 myFunctions.runChessEngine(10);
  742.                 break;
  743.             case 65:
  744.                 myFunctions.runChessEngine(11);
  745.                 break;
  746.             case 83:
  747.                 myFunctions.runChessEngine(12);
  748.                 break;
  749.             case 68:
  750.                 myFunctions.runChessEngine(13);
  751.                 break;
  752.             case 70:
  753.                 myFunctions.runChessEngine(14);
  754.                 break;
  755.             case 71:
  756.                 myFunctions.runChessEngine(15);
  757.                 break;
  758.             case 72:
  759.                 myFunctions.runChessEngine(16);
  760.                 break;
  761.             case 74:
  762.                 myFunctions.runChessEngine(17);
  763.                 break;
  764.             case 75:
  765.                 myFunctions.runChessEngine(18);
  766.                 break;
  767.             case 76:
  768.                 myFunctions.runChessEngine(19);
  769.                 break;
  770.             case 90:
  771.                 myFunctions.runChessEngine(20);
  772.                 break;
  773.             case 88:
  774.                 myFunctions.runChessEngine(21);
  775.                 break;
  776.             case 67:
  777.                 myFunctions.runChessEngine(22);
  778.                 break;
  779.             case 86:
  780.                 myFunctions.runChessEngine(23);
  781.                 break;
  782.             case 66:
  783.                 myFunctions.runChessEngine(24);
  784.                 break;
  785.             case 78:
  786.                 myFunctions.runChessEngine(25);
  787.                 break;
  788.             case 77:
  789.                 myFunctions.runChessEngine(26);
  790.                 break;
  791.             case 187:
  792.                 myFunctions.runChessEngine(100);
  793.                 break;
  794.         }
  795.     };
  796.  
  797.     myFunctions.spinner = function() {
  798.         if(isThinking == true){
  799.             $('#thinking-indicator').addClass('active');
  800.         }
  801.         if(isThinking == false) {
  802.             $('#thinking-indicator').removeClass('active');
  803.         }
  804.     }
  805.  
  806.     let dynamicStyles = null;
  807.  
  808.     function addAnimation(body) {
  809.         if (!dynamicStyles) {
  810.             dynamicStyles = document.createElement('style');
  811.             dynamicStyles.type = 'text/css';
  812.             document.head.appendChild(dynamicStyles);
  813.         }
  814.  
  815.         dynamicStyles.sheet.insertRule(body, dynamicStyles.length);
  816.     }
  817.  
  818.     var loaded = false;
  819.     myFunctions.loadEx = function(){
  820.         try{
  821.             var tmpStyle;
  822.             var tmpDiv;
  823.             board = $('chess-board')[0] || $('wc-chess-board')[0];
  824.             myVars.board = board;
  825.  
  826.             var div = document.createElement('div')
  827.             var content = `
  828.             <div class="chess-bot-container">
  829.                 <div class="bot-header">
  830.                     <div class="bot-logo">
  831.                         <svg viewBox="0 0 24 24" width="24" height="24">
  832.                             <path fill="currentColor" d="M19,22H5V20H19V22M17,10C15.58,10 14.26,10.77 13.55,12H13V7H16V5H13V2H11V5H8V7H11V12H10.45C9.74,10.77 8.42,10 7,10A5,5 0 0,0 2,15A5,5 0 0,0 7,20H17A5,5 0 0,0 22,15A5,5 0 0,0 17,10M7,18A3,3 0 0,1 4,15A3,3 0 0,1 7,12A3,3 0 0,1 10,15A3,3 0 0,1 7,18M17,18A3,3 0 0,1 14,15A3,3 0 0,1 17,12A3,3 0 0,1 20,15A3,3 0 0,1 17,18Z" />
  833.                         </svg>
  834.                     </div>
  835.                     <h3 class="bot-title">Panel Pro By @akashdeep</h3>
  836.                     <div id="thinking-indicator" class="thinking-indicator">
  837.                         <span class="dot dot1"></span>
  838.                         <span class="dot dot2"></span>
  839.                         <span class="dot dot3"></span>
  840.                     </div>
  841.                 </div>
  842.  
  843.                 <div class="bot-tabs">
  844.                     <button class="tab-button active" data-tab="main-settings">Main</button>
  845.                     <button class="tab-button" data-tab="style-settings">Play Style</button>
  846.                     <button class="tab-button" data-tab="advanced-settings">Advanced</button>
  847.                 </div>
  848.  
  849.                 <div class="bot-tabs-content">
  850.                     <div class="tab-content active" id="main-settings">
  851.                         <div class="bot-info">
  852.                             <div class="depth-card">
  853.                                 <p id="depthText" class="depth-display">Current Depth: <strong>11</strong></p>
  854.                                 <p class="key-hint">Press a key (Q-Z) to change depth</p>
  855.  
  856.                                 <div class="depth-control">
  857.                                     <label for="depthSlider">Depth/ELO:</label>
  858.                                     <div class="slider-controls">
  859.                                         <button class="depth-button" id="decreaseDepth">-</button>
  860.                                         <input type="range" id="depthSlider" min="1" max="21" value="11" class="depth-slider">
  861.                                         <button class="depth-button" id="increaseDepth">+</button>
  862.                                     </div>
  863.                                     <span id="depthValue">11</span>
  864.                                 </div>
  865.                             </div>
  866.                         </div>
  867.  
  868.                         <div class="bot-controls">
  869.                             <div class="control-group">
  870.                                 <div class="control-item toggle-container">
  871.                                     <input type="checkbox" id="autoRun" name="autoRun" class="toggle-input" value="false">
  872.                                     <label for="autoRun" class="toggle-label">
  873.                                         <span class="toggle-button"></span>
  874.                                         <span class="toggle-text">Auto Run</span>
  875.                                     </label>
  876.                                 </div>
  877.  
  878.                                 <div class="control-item toggle-container">
  879.                                     <input type="checkbox" id="autoMove" name="autoMove" class="toggle-input" value="false">
  880.                                     <label for="autoMove" class="toggle-label">
  881.                                         <span class="toggle-button"></span>
  882.                                         <span class="toggle-text">Auto Move</span>
  883.                                     </label>
  884.                                 </div>
  885.                             </div>
  886.  
  887.                             <div class="control-group">
  888.                                 <div class="control-item slider-container">
  889.                                     <label for="timeDelayMin">Min Delay (sec)</label>
  890.                                     <input type="number" id="timeDelayMin" name="timeDelayMin" min="0.1" value="0.1" step="0.1" class="number-input">
  891.                                 </div>
  892.  
  893.                                 <div class="control-item slider-container">
  894.                                     <label for="timeDelayMax">Max Delay (sec)</label>
  895.                                     <input type="number" id="timeDelayMax" name="timeDelayMax" min="0.1" value="1" step="0.1" class="number-input">
  896.                                 </div>
  897.                             </div>
  898.                         </div>
  899.                     </div>
  900.  
  901.                     <div class="tab-content" id="style-settings">
  902.                         <div class="playStyle-controls">
  903.                             <h4 class="settings-section-title">Playing Style Settings</h4>
  904.  
  905.                             <div class="style-slider-container">
  906.                                 <label for="aggressiveSlider">Aggressive Play:</label>
  907.                                 <input type="range" id="aggressiveSlider" min="1" max="10" value="5" class="style-slider">
  908.                                 <span id="aggressiveValue">5</span>
  909.                             </div>
  910.  
  911.                             <div class="style-slider-container">
  912.                                 <label for="defensiveSlider">Defensive Play:</label>
  913.                                 <input type="range" id="defensiveSlider" min="1" max="10" value="5" class="style-slider">
  914.                                 <span id="defensiveValue">5</span>
  915.                             </div>
  916.  
  917.                             <div class="style-slider-container">
  918.                                 <label for="tacticalSlider">Tactical Play:</label>
  919.                                 <input type="range" id="tacticalSlider" min="1" max="10" value="5" class="style-slider">
  920.                                 <span id="tacticalValue">5</span>
  921.                             </div>
  922.  
  923.                             <div class="style-slider-container">
  924.                                 <label for="positionalSlider">Positional Play:</label>
  925.                                 <input type="range" id="positionalSlider" min="1" max="10" value="5" class="style-slider">
  926.                                 <span id="positionalValue">5</span>
  927.                             </div>
  928.  
  929.                             <div class="style-slider-container">
  930.                                 <label for="blunderRateSlider">Blunder Rate:</label>
  931.                                 <input type="range" id="blunderRateSlider" min="0" max="10" value="2" class="style-slider">
  932.                                 <span id="blunderRateValue">2</span>
  933.                             </div>
  934.                         </div>
  935.                     </div>
  936.  
  937.                     <div class="tab-content" id="advanced-settings">
  938.                         <div class="advanced-controls">
  939.                             <h4 class="settings-section-title">Advanced Settings</h4>
  940.  
  941.                             <div class="control-item toggle-container">
  942.                                 <input type="checkbox" id="adaptToRating" name="adaptToRating" class="toggle-input" value="true" checked>
  943.                                 <label for="adaptToRating" class="toggle-label">
  944.                                     <span class="toggle-button"></span>
  945.                                     <span class="toggle-text">Adapt to opponent rating</span>
  946.                                 </label>
  947.                             </div>
  948.  
  949.                             <div class="control-item toggle-container">
  950.                                 <input type="checkbox" id="useOpeningBook" name="useOpeningBook" class="toggle-input" value="true" checked>
  951.                                 <label for="useOpeningBook" class="toggle-label">
  952.                                     <span class="toggle-button"></span>
  953.                                     <span class="toggle-text">Use personalized openings</span>
  954.                                 </label>
  955.                             </div>
  956.  
  957.                             <div class="highlight-color-picker">
  958.                                 <label for="highlightColor">Move highlight color:</label>
  959.                                 <input type="color" id="highlightColor" value="#eb6150" class="color-input">
  960.                             </div>
  961.  
  962.                             <div class="opening-selection">
  963.                                 <label for="preferredOpeningSelect">Preferred Opening:</label>
  964.                                 <select id="preferredOpeningSelect" class="select-input">
  965.                                     <option value="random">Random</option>
  966.                                     <option value="e4">e4 (King's Pawn)</option>
  967.                                     <option value="d4">d4 (Queen's Pawn)</option>
  968.                                     <option value="c4">c4 (English)</option>
  969.                                     <option value="Nf3">Nf3 (Réti)</option>
  970.                                 </select>
  971.                             </div>
  972.                         </div>
  973.                     </div>
  974.                 </div>
  975.  
  976.                 <div class="bot-actions">
  977.                     <button type="button" id="relEngBut" class="action-button primary-button" onclick="document.myFunctions.reloadChessEngine()">
  978.                         <svg viewBox="0 0 24 24" width="16" height="16">
  979.                             <path fill="currentColor" d="M17.65,6.35C16.2,4.9 14.21,4 12,4A8,8 0 0,0 4,12A8,8 0 0,0 12,20C15.73,20 18.84,17.45 19.73,14H17.65C16.83,16.33 14.61,18 12,18A6,6 0 0,1 6,12A6,6 0 0,1 12,6C13.66,6 15.14,6.69 16.22,7.78L13,11H20V4L17.65,6.35Z" />
  980.                         </svg>
  981.                         Reload Engine
  982.                     </button>
  983.  
  984.                     <button type="button" id="isBut" class="action-button secondary-button" onclick="window.confirm('Can I take you to the issues page?') ? document.location = 'https://github.com/Auzgame/userscripts/issues' : console.log('canceled')">
  985.                         <svg viewBox="0 0 24 24" width="16" height="16">
  986.                             <path fill="currentColor" d="M13,13H11V7H13M13,17H11V15H13M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12A10,10 0 0,0 12,2Z" />
  987.                         </svg>
  988.                         Report Issue
  989.                     </button>
  990.                 </div>
  991.             </div>`;
  992.             div.innerHTML = content;
  993.             div.setAttribute('id','settingsContainer');
  994.  
  995.             board.parentElement.parentElement.appendChild(div);
  996.  
  997.             //Add CSS styles
  998.             var botStyles = document.createElement('style');
  999.             botStyles.innerHTML = `
  1000.                 @import url('https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;700&display=swap');
  1001.  
  1002.                 #settingsContainer {
  1003.                     background-color: #1e1e2e;
  1004.                     color: #cdd6f4;
  1005.                     border-radius: 12px;
  1006.                     padding: 20px;
  1007.                     margin-top: 15px;
  1008.                     box-shadow: 0 8px 24px rgba(0,0,0,0.3);
  1009.                     font-family: 'Roboto', sans-serif;
  1010.                     max-width: 400px;
  1011.                     margin-left: auto;
  1012.                     margin-right: auto;
  1013.                     border: 1px solid #313244;
  1014.                 }
  1015.  
  1016.                 .chess-bot-container {
  1017.                     display: flex;
  1018.                     flex-direction: column;
  1019.                     gap: 16px;
  1020.                 }
  1021.  
  1022.                 .bot-header {
  1023.                     display: flex;
  1024.                     align-items: center;
  1025.                     justify-content: center;
  1026.                     gap: 10px;
  1027.                     margin-bottom: 5px;
  1028.                     position: relative;
  1029.                 }
  1030.  
  1031.                 .bot-logo {
  1032.                     display: flex;
  1033.                     align-items: center;
  1034.                     justify-content: center;
  1035.                     color: #89b4fa;
  1036.                 }
  1037.  
  1038.                 .bot-title {
  1039.                     margin: 0;
  1040.                     color: #89b4fa;
  1041.                     font-size: 20px;
  1042.                     font-weight: 500;
  1043.                     letter-spacing: 0.5px;
  1044.                 }
  1045.  
  1046.                 .thinking-indicator {
  1047.                     position: absolute;
  1048.                     right: 0;
  1049.                     display: none;
  1050.                     align-items: center;
  1051.                 }
  1052.  
  1053.                 .thinking-indicator.active {
  1054.                     display: flex;
  1055.                 }
  1056.  
  1057.                 .dot {
  1058.                     width: 8px;
  1059.                     height: 8px;
  1060.                     margin: 0 2px;
  1061.                     background-color: #89b4fa;
  1062.                     border-radius: 50%;
  1063.                     opacity: 0.6;
  1064.                 }
  1065.  
  1066.                 .dot1 {
  1067.                     animation: pulse 1.5s infinite;
  1068.                 }
  1069.  
  1070.                 .dot2 {
  1071.                     animation: pulse 1.5s infinite 0.3s;
  1072.                 }
  1073.  
  1074.                 .dot3 {
  1075.                     animation: pulse 1.5s infinite 0.6s;
  1076.                 }
  1077.  
  1078.                 @keyframes pulse {
  1079.                     0%, 100% {
  1080.                         transform: scale(1);
  1081.                         opacity: 0.6;
  1082.                     }
  1083.                     50% {
  1084.                         transform: scale(1.3);
  1085.                         opacity: 1;
  1086.                     }
  1087.                 }
  1088.  
  1089.                 .bot-tabs {
  1090.                     display: flex;
  1091.                     gap: 2px;
  1092.                     margin-bottom: -15px;
  1093.                 }
  1094.  
  1095.                 .tab-button {
  1096.                     background-color: #313244;
  1097.                     color: #a6adc8;
  1098.                     border: none;
  1099.                     border-radius: 8px 8px 0 0;
  1100.                     padding: 8px 16px;
  1101.                     cursor: pointer;
  1102.                     font-size: 14px;
  1103.                     font-weight: 500;
  1104.                     transition: all 0.2s;
  1105.                     flex: 1;
  1106.                     text-align: center;
  1107.                 }
  1108.  
  1109.                 .tab-button:hover {
  1110.                     background-color: #45475a;
  1111.                     color: #cdd6f4;
  1112.                 }
  1113.  
  1114.                 .tab-button.active {
  1115.                     background-color: #45475a;
  1116.                     color: #cdd6f4;
  1117.                 }
  1118.  
  1119.                 .bot-tabs-content {
  1120.                     background-color: #45475a;
  1121.                     border-radius: 0 8px 8px 8px;
  1122.                     padding: 16px;
  1123.                 }
  1124.  
  1125.                 .tab-content {
  1126.                     display: none;
  1127.                 }
  1128.  
  1129.                 .tab-content.active {
  1130.                     display: block;
  1131.                 }
  1132.  
  1133.                 .settings-section-title {
  1134.                     margin-top: 0;
  1135.                     margin-bottom: 12px;
  1136.                     color: #89b4fa;
  1137.                     font-size: 16px;
  1138.                     font-weight: 500;
  1139.                     text-align: center;
  1140.                 }
  1141.  
  1142.                 .bot-info {
  1143.                     display: flex;
  1144.                     justify-content: center;
  1145.                     margin-bottom: 5px;
  1146.                 }
  1147.  
  1148.                 .depth-card {
  1149.                     background-color: #313244;
  1150.                     border-radius: 8px;
  1151.                     padding: 12px 16px;
  1152.                     text-align: center;
  1153.                     width: 100%;
  1154.                     border: 1px solid #45475a;
  1155.                 }
  1156.  
  1157.                 .depth-display {
  1158.                     font-size: 16px;
  1159.                     margin: 0 0 5px 0;
  1160.                     font-weight: 400;
  1161.                 }
  1162.  
  1163.                 .depth-display strong {
  1164.                     color: #89b4fa;
  1165.                     font-weight: 600;
  1166.                 }
  1167.  
  1168.                 .key-hint {
  1169.                     font-size: 12px;
  1170.                     color: #a6adc8;
  1171.                     margin: 0;
  1172.                     font-weight: 300;
  1173.                 }
  1174.  
  1175.                 .bot-controls {
  1176.                     display: flex;
  1177.                     flex-direction: column;
  1178.                     gap: 16px;
  1179.                 }
  1180.  
  1181.                 .control-group {
  1182.                     display: grid;
  1183.                     grid-template-columns: 1fr 1fr;
  1184.                     gap: 12px;
  1185.                 }
  1186.  
  1187.                 .control-item {
  1188.                     display: flex;
  1189.                     flex-direction: column;
  1190.                     gap: 6px;
  1191.                 }
  1192.  
  1193.                 .toggle-container {
  1194.                     position: relative;
  1195.                 }
  1196.  
  1197.                 .toggle-input {
  1198.                     opacity: 0;
  1199.                     width: 0;
  1200.                     height: 0;
  1201.                     position: absolute;
  1202.                 }
  1203.  
  1204.                 .toggle-label {
  1205.                     display: flex;
  1206.                     align-items: center;
  1207.                     gap: 10px;
  1208.                     cursor: pointer;
  1209.                 }
  1210.  
  1211.                 .toggle-button {
  1212.                     position: relative;
  1213.                     display: inline-block;
  1214.                     width: 40px;
  1215.                     height: 20px;
  1216.                     background-color: #45475a;
  1217.                     border-radius: 20px;
  1218.                     transition: all 0.3s;
  1219.                 }
  1220.  
  1221.                 .toggle-button:before {
  1222.                     content: '';
  1223.                     position: absolute;
  1224.                     width: 16px;
  1225.                     height: 16px;
  1226.                     border-radius: 50%;
  1227.                     background-color: #cdd6f4;
  1228.                     top: 2px;
  1229.                     left: 2px;
  1230.                     transition: all 0.3s;
  1231.                 }
  1232.  
  1233.                 .toggle-input:checked + .toggle-label .toggle-button {
  1234.                     background-color: #89b4fa;
  1235.                 }
  1236.  
  1237.                 .toggle-input:checked + .toggle-label .toggle-button:before {
  1238.                     transform: translateX(20px);
  1239.                 }
  1240.  
  1241.                 .toggle-text {
  1242.                     font-size: 14px;
  1243.                 }
  1244.  
  1245.                 .slider-container {
  1246.                     display: flex;
  1247.                     flex-direction: column;
  1248.                     gap: 6px;
  1249.                 }
  1250.  
  1251.                 .slider-container label {
  1252.                     font-size: 13px;
  1253.                     color: #a6adc8;
  1254.                 }
  1255.  
  1256.                 .number-input {
  1257.                     width: 100%;
  1258.                     background: #313244;
  1259.                     border: 1px solid #45475a;
  1260.                     border-radius: 6px;
  1261.                     color: #cdd6f4;
  1262.                     padding: 8px 10px;
  1263.                     font-size: 14px;
  1264.                     transition: border-color 0.3s;
  1265.                 }
  1266.  
  1267.                 .number-input:focus {
  1268.                     outline: none;
  1269.                     border-color: #89b4fa;
  1270.                 }
  1271.  
  1272.                 .bot-actions {
  1273.                     display: grid;
  1274.                     grid-template-columns: 1fr 1fr;
  1275.                     gap: 12px;
  1276.                     margin-top: 5px;
  1277.                 }
  1278.  
  1279.                 .action-button {
  1280.                     display: flex;
  1281.                     align-items: center;
  1282.                     justify-content: center;
  1283.                     gap: 8px;
  1284.                     border: none;
  1285.                     border-radius: 8px;
  1286.                     padding: 10px 16px;
  1287.                     font-size: 14px;
  1288.                     font-weight: 500;
  1289.                     cursor: pointer;
  1290.                     transition: all 0.2s;
  1291.                 }
  1292.  
  1293.                 .primary-button {
  1294.                     background-color: #89b4fa;
  1295.                     color: #1e1e2e;
  1296.                 }
  1297.  
  1298.                 .primary-button:hover {
  1299.                     background-color: #b4befe;
  1300.                     transform: translateY(-2px);
  1301.                     box-shadow: 0 4px 8px rgba(137, 180, 250, 0.3);
  1302.                 }
  1303.  
  1304.                 .secondary-button {
  1305.                     background-color: #45475a;
  1306.                     color: #cdd6f4;
  1307.                 }
  1308.  
  1309.                 .secondary-button:hover {
  1310.                     background-color: #585b70;
  1311.                     transform: translateY(-2px);
  1312.                     box-shadow: 0 4px 8px rgba(69, 71, 90, 0.3);
  1313.                 }
  1314.  
  1315.                 .action-button:active {
  1316.                     transform: translateY(0);
  1317.                 }
  1318.  
  1319.                 .depth-control {
  1320.                     margin-top: 12px;
  1321.                     display: flex;
  1322.                     flex-direction: column;
  1323.                     gap: 8px;
  1324.                 }
  1325.  
  1326.                 .depth-control label {
  1327.                     font-size: 13px;
  1328.                     color: #a6adc8;
  1329.                 }
  1330.  
  1331.                 .slider-controls {
  1332.                     display: flex;
  1333.                     align-items: center;
  1334.                     gap: 8px;
  1335.                 }
  1336.  
  1337.                 .depth-slider {
  1338.                     flex: 1;
  1339.                     height: 6px;
  1340.                     -webkit-appearance: none;
  1341.                     appearance: none;
  1342.                     background: #45475a;
  1343.                     border-radius: 3px;
  1344.                     outline: none;
  1345.                 }
  1346.  
  1347.                 .depth-slider::-webkit-slider-thumb {
  1348.                     -webkit-appearance: none;
  1349.                     appearance: none;
  1350.                     width: 16px;
  1351.                     height: 16px;
  1352.                     border-radius: 50%;
  1353.                     background: #89b4fa;
  1354.                     cursor: pointer;
  1355.                 }
  1356.  
  1357.                 .depth-slider::-moz-range-thumb {
  1358.                     width: 16px;
  1359.                     height: 16px;
  1360.                     border-radius: 50%;
  1361.                     background: #89b4fa;
  1362.                     cursor: pointer;
  1363.                 }
  1364.  
  1365.                 .depth-button {
  1366.                     width: 24px;
  1367.                     height: 24px;
  1368.                     border-radius: 50%;
  1369.                     background: #45475a;
  1370.                     color: #cdd6f4;
  1371.                     border: none;
  1372.                     display: flex;
  1373.                     align-items: center;
  1374.                     justify-content: center;
  1375.                     cursor: pointer;
  1376.                     font-size: 16px;
  1377.                     font-weight: bold;
  1378.                     transition: background-color 0.2s;
  1379.                 }
  1380.  
  1381.                 .depth-button:hover {
  1382.                     background: #585b70;
  1383.                 }
  1384.  
  1385.                 #depthValue {
  1386.                     font-size: 14px;
  1387.                     font-weight: 500;
  1388.                     color: #89b4fa;
  1389.                     text-align: center;
  1390.                 }
  1391.             `;
  1392.             document.head.appendChild(botStyles);
  1393.  
  1394.             //spinnerContainer
  1395.             var spinCont = document.createElement('div');
  1396.             spinCont.setAttribute('style','display:none;');
  1397.             spinCont.setAttribute('id','overlay');
  1398.             div.prepend(spinCont);
  1399.  
  1400.             //spinner
  1401.             var spinr = document.createElement('div')
  1402.             spinr.setAttribute('style',`
  1403.             margin: 0 auto;
  1404.             height: 40px;
  1405.             width: 40px;
  1406.             animation: rotate 0.8s infinite linear;
  1407.             border: 4px solid #89b4fa;
  1408.             border-right-color: transparent;
  1409.             border-radius: 50%;
  1410.             box-shadow: 0 0 10px rgba(137, 180, 250, 0.4);
  1411.             `);
  1412.             spinCont.appendChild(spinr);
  1413.             addAnimation(`@keyframes rotate {
  1414.                            0% {
  1415.                                transform: rotate(0deg);
  1416.                               }
  1417.                          100% {
  1418.                                transform: rotate(360deg);
  1419.                               }
  1420.                                            }`);
  1421.                                            $('#depthSlider').on('input', function() {
  1422.                                             const depth = parseInt($(this).val());
  1423.                                             $('#depthValue').text(depth);
  1424.                                             lastValue = depth;
  1425.                                             $('#depthText')[0].innerHTML = "Current Depth: <strong>" + depth + "</strong>";
  1426.                                         });
  1427.  
  1428.                                         $('#decreaseDepth').on('click', function() {
  1429.                                             const currentDepth = parseInt($('#depthSlider').val());
  1430.                                             if (currentDepth > 1) {
  1431.                                                 const newDepth = currentDepth - 1;
  1432.                                                 $('#depthSlider').val(newDepth).trigger('input');
  1433.                                             }
  1434.                                         });
  1435.  
  1436.                                         $('#increaseDepth').on('click', function() {
  1437.                                             const currentDepth = parseInt($('#depthSlider').val());
  1438.                                             if (currentDepth < 26) {
  1439.                                                 const newDepth = currentDepth + 1;
  1440.                                                 $('#depthSlider').val(newDepth).trigger('input');
  1441.                                             }
  1442.                                         });
  1443.  
  1444.                                         // Fix tab switching and initialize all controls
  1445.                                         $(document).on('click', '.tab-button', function() {
  1446.                                             $('.tab-button').removeClass('active');
  1447.                                             $(this).addClass('active');
  1448.  
  1449.                                             const tabId = $(this).data('tab');
  1450.                                             $('.tab-content').removeClass('active');
  1451.                                             $(`#${tabId}`).addClass('active');
  1452.                                         });
  1453.  
  1454.                                         // Initialize play style sliders with values from myVars
  1455.                                         if (myVars.playStyle) {
  1456.                                             $('#aggressiveSlider').val(Math.round(((myVars.playStyle.aggressive - 0.3) / 0.5) * 10));
  1457.                                             $('#aggressiveValue').text($('#aggressiveSlider').val());
  1458.  
  1459.                                             $('#defensiveSlider').val(Math.round(((myVars.playStyle.defensive - 0.3) / 0.5) * 10));
  1460.                                             $('#defensiveValue').text($('#defensiveSlider').val());
  1461.  
  1462.                                             $('#tacticalSlider').val(Math.round(((myVars.playStyle.tactical - 0.2) / 0.6) * 10));
  1463.                                             $('#tacticalValue').text($('#tacticalSlider').val());
  1464.  
  1465.                                             $('#positionalSlider').val(Math.round(((myVars.playStyle.positional - 0.2) / 0.6) * 10));
  1466.                                             $('#positionalValue').text($('#positionalSlider').val());
  1467.                                         }
  1468.  
  1469.                                         // Set the blunder rate slider
  1470.                                         const blunderRate = myVars.blunderRate !== undefined ? Math.round(myVars.blunderRate * 10) : 2;
  1471.                                         $('#blunderRateSlider').val(blunderRate);
  1472.                                         $('#blunderRateValue').text(blunderRate);
  1473.  
  1474.                                         // Setup the style sliders
  1475.                                         $('.style-slider').on('input', function() {
  1476.                                             const value = $(this).val();
  1477.                                             $(`#${this.id}Value`).text(value);
  1478.  
  1479.                                             // Update the myVars.playStyle object
  1480.                                             const styleType = this.id.replace('Slider', '');
  1481.                                             if (styleType === 'blunderRate') {
  1482.                                                 myVars.blunderRate = parseFloat(value) / 10;
  1483.                                             } else if (myVars.playStyle && styleType in myVars.playStyle) {
  1484.                                                 if (styleType === 'aggressive' || styleType === 'defensive') {
  1485.                                                     myVars.playStyle[styleType] = 0.3 + (parseFloat(value) / 10) * 0.5;
  1486.                                                 } else {
  1487.                                                     myVars.playStyle[styleType] = 0.2 + (parseFloat(value) / 10) * 0.6;
  1488.                                                 }
  1489.                                             }
  1490.                                         });
  1491.  
  1492.                                         // Initialize advanced settings
  1493.                                         if (myVars.adaptToRating !== undefined) {
  1494.                                             $('#adaptToRating').prop('checked', myVars.adaptToRating);
  1495.                                         }
  1496.  
  1497.                                         if (myVars.useOpeningBook !== undefined) {
  1498.                                             $('#useOpeningBook').prop('checked', myVars.useOpeningBook);
  1499.                                         }
  1500.  
  1501.                                         if (myVars.highlightColor) {
  1502.                                             $('#highlightColor').val(myVars.highlightColor);
  1503.                                         }
  1504.  
  1505.                                         // Set up preferred opening selection
  1506.                                         if (myVars.preferredOpenings && myVars.preferredOpenings.length === 1) {
  1507.                                             $('#preferredOpeningSelect').val(myVars.preferredOpenings[0]);
  1508.                                         } else {
  1509.                                             $('#preferredOpeningSelect').val('random');
  1510.                                         }
  1511.  
  1512.                                         // Set up advanced settings event handlers
  1513.                                         $('#adaptToRating').on('change', function() {
  1514.                                             myVars.adaptToRating = $(this).prop('checked');
  1515.                                         });
  1516.  
  1517.                                         $('#useOpeningBook').on('change', function() {
  1518.                                             myVars.useOpeningBook = $(this).prop('checked');
  1519.                                         });
  1520.  
  1521.                                         $('#highlightColor').on('input', function() {
  1522.                                             myVars.highlightColor = $(this).val();
  1523.                                         });
  1524.  
  1525.                                         $('#preferredOpeningSelect').on('change', function() {
  1526.                                             const selectedOpening = $(this).val();
  1527.                                             if (selectedOpening === 'random') {
  1528.                                                 myVars.preferredOpenings = ["e4", "d4", "c4", "Nf3"].sort(() => Math.random() - 0.5);
  1529.                                             } else {
  1530.                                                 myVars.preferredOpenings = [selectedOpening];
  1531.                                             }
  1532.                                         });
  1533.  
  1534.                                         // Setup hotkey options and additional config
  1535.                                         const extraSettings = `
  1536.                                         <div class="advanced-section">
  1537.                                             <div class="control-item toggle-container">
  1538.                                                 <input type="checkbox" id="enableHotkeys" name="enableHotkeys" class="toggle-input" checked>
  1539.                                                 <label for="enableHotkeys" class="toggle-label">
  1540.                                                     <span class="toggle-button"></span>
  1541.                                                     <span class="toggle-text">Enable keyboard shortcuts</span>
  1542.                                                 </label>
  1543.                                             </div>
  1544.  
  1545.                                             <div class="control-item toggle-container">
  1546.                                                 <input type="checkbox" id="randomizeTiming" name="randomizeTiming" class="toggle-input" checked>
  1547.                                                 <label for="randomizeTiming" class="toggle-label">
  1548.                                                     <span class="toggle-button"></span>
  1549.                                                     <span class="toggle-text">Randomize thinking time</span>
  1550.                                                 </label>
  1551.                                             </div>
  1552.  
  1553.                                             <div class="style-slider-container">
  1554.                                                 <label for="mouseMovementSlider">Mouse Movement Realism:</label>
  1555.                                                 <input type="range" id="mouseMovementSlider" min="1" max="10" value="7" class="style-slider">
  1556.                                                 <span id="mouseMovementSliderValue">7</span>
  1557.                                             </div>
  1558.  
  1559.                                             <div class="profile-selection">
  1560.                                                 <label for="playingProfileSelect">Playing Profile:</label>
  1561.                                                 <select id="playingProfileSelect" class="select-input">
  1562.                                                     <option value="custom">Custom Settings</option>
  1563.                                                     <option value="beginner">Beginner (≈800)</option>
  1564.                                                     <option value="intermediate">Intermediate (≈1200)</option>
  1565.                                                     <option value="advanced">Advanced (≈1600)</option>
  1566.                                                     <option value="expert">Expert (≈2000)</option>
  1567.                                                     <option value="master">Master (≈2400+)</option>
  1568.                                                 </select>
  1569.                                             </div>
  1570.                                         </div>
  1571.                                         `;
  1572.  
  1573.                                         $('#advanced-settings .advanced-controls').append(extraSettings);
  1574.  
  1575.                                         // Initialize additional settings
  1576.                                         myVars.enableHotkeys = true;
  1577.                                         myVars.randomizeTiming = true;
  1578.                                         myVars.mouseMovementRealism = 0.7;
  1579.  
  1580.                                         // Setup additional event handlers
  1581.                                         $('#enableHotkeys').on('change', function() {
  1582.                                             myVars.enableHotkeys = $(this).prop('checked');
  1583.                                         });
  1584.  
  1585.                                         $('#randomizeTiming').on('change', function() {
  1586.                                             myVars.randomizeTiming = $(this).prop('checked');
  1587.                                         });
  1588.  
  1589.                                         $('#mouseMovementSlider').on('input', function() {
  1590.                                             const value = $(this).val();
  1591.                                             $('#mouseMovementSliderValue').text(value);
  1592.                                             myVars.mouseMovementRealism = parseFloat(value) / 10;
  1593.                                         });
  1594.  
  1595.                                         $('#playingProfileSelect').on('change', function() {
  1596.                                             const profile = $(this).val();
  1597.  
  1598.                                             if (profile !== 'custom') {
  1599.                                                 // Preset profiles with appropriate settings
  1600.                                                 switch(profile) {
  1601.                                                     case 'beginner':
  1602.                                                         $('#depthSlider').val(3).trigger('input');
  1603.                                                         $('#blunderRateSlider').val(7).trigger('input');
  1604.                                                         $('#aggressiveSlider').val(Math.floor(3 + Math.random() * 5)).trigger('input');
  1605.                                                         $('#tacticalSlider').val(3).trigger('input');
  1606.                                                         break;
  1607.                                                     case 'intermediate':
  1608.                                                         $('#depthSlider').val(6).trigger('input');
  1609.                                                         $('#blunderRateSlider').val(5).trigger('input');
  1610.                                                         $('#tacticalSlider').val(5).trigger('input');
  1611.                                                         break;
  1612.                                                     case 'advanced':
  1613.                                                         $('#depthSlider').val(9).trigger('input');
  1614.                                                         $('#blunderRateSlider').val(3).trigger('input');
  1615.                                                         $('#tacticalSlider').val(7).trigger('input');
  1616.                                                         break;
  1617.                                                     case 'expert':
  1618.                                                         $('#depthSlider').val(12).trigger('input');
  1619.                                                         $('#blunderRateSlider').val(2).trigger('input');
  1620.                                                         $('#tacticalSlider').val(8).trigger('input');
  1621.                                                         $('#positionalSlider').val(8).trigger('input');
  1622.                                                         break;
  1623.                                                     case 'master':
  1624.                                                         $('#depthSlider').val(15).trigger('input');
  1625.                                                         $('#blunderRateSlider').val(1).trigger('input');
  1626.                                                         $('#tacticalSlider').val(9).trigger('input');
  1627.                                                         $('#positionalSlider').val(9).trigger('input');
  1628.                                                         break;
  1629.                                                 }
  1630.                                             }
  1631.                                         });
  1632.  
  1633.                                         // Add CSS for new elements
  1634.                                         const extraStyles = document.createElement('style');
  1635.                                         extraStyles.innerHTML = `
  1636.                                             .advanced-section {
  1637.                                                 margin-top: 15px;
  1638.                                                 padding-top: 15px;
  1639.                                                 border-top: 1px solid #313244;
  1640.                                             }
  1641.  
  1642.                                             .profile-selection {
  1643.                                                 margin-top: 15px;
  1644.                                             }
  1645.  
  1646.                                             .playStyle-controls, .advanced-controls {
  1647.                                                 display: flex;
  1648.                                                 flex-direction: column;
  1649.                                                 gap: 12px;
  1650.                                             }
  1651.  
  1652.                                             .style-slider-container {
  1653.                                                 display: flex;
  1654.                                                 align-items: center;
  1655.                                                 gap: 10px;
  1656.                                             }
  1657.  
  1658.                                             .style-slider-container label {
  1659.                                                 font-size: 13px;
  1660.                                                 color: #cdd6f4;
  1661.                                                 width: 120px;
  1662.                                             }
  1663.  
  1664.                                             .style-slider {
  1665.                                                 flex: 1;
  1666.                                                 height: 6px;
  1667.                                                 -webkit-appearance: none;
  1668.                                                 appearance: none;
  1669.                                                 background: #313244;
  1670.                                                 border-radius: 3px;
  1671.                                                 outline: none;
  1672.                                             }
  1673.  
  1674.                                             .style-slider::-webkit-slider-thumb {
  1675.                                                 -webkit-appearance: none;
  1676.                                                 appearance: none;
  1677.                                                 width: 14px;
  1678.                                                 height: 14px;
  1679.                                                 border-radius: 50%;
  1680.                                                 background: #89b4fa;
  1681.                                                 cursor: pointer;
  1682.                                             }
  1683.  
  1684.                                             .style-slider-container span {
  1685.                                                 font-size: 14px;
  1686.                                                 font-weight: 500;
  1687.                                                 color: #89b4fa;
  1688.                                                 width: 20px;
  1689.                                                 text-align: center;
  1690.                                             }
  1691.  
  1692.                                             .highlight-color-picker {
  1693.                                                 display: flex;
  1694.                                                 align-items: center;
  1695.                                                 gap: 10px;
  1696.                                                 margin-top: 10px;
  1697.                                             }
  1698.  
  1699.                                             .highlight-color-picker label {
  1700.                                                 font-size: 13px;
  1701.                                                 color: #cdd6f4;
  1702.                                             }
  1703.  
  1704.                                             .color-input {
  1705.                                                 -webkit-appearance: none;
  1706.                                                 width: 30px;
  1707.                                                 height: 30px;
  1708.                                                 border: none;
  1709.                                                 border-radius: 50%;
  1710.                                                 background: none;
  1711.                                                 cursor: pointer;
  1712.                                             }
  1713.  
  1714.                                             .color-input::-webkit-color-swatch {
  1715.                                                 border: none;
  1716.                                                 border-radius: 50%;
  1717.                                                 box-shadow: 0 0 0 2px #45475a;
  1718.                                             }
  1719.  
  1720.                                             .opening-selection {
  1721.                                                 display: flex;
  1722.                                                 align-items: center;
  1723.                                                 gap: 10px;
  1724.                                                 margin-top: 10px;
  1725.                                             }
  1726.  
  1727.                                             .opening-selection label {
  1728.                                                 font-size: 13px;
  1729.                                                 color: #cdd6f4;
  1730.                                             }
  1731.  
  1732.                                             .select-input {
  1733.                                                 flex: 1;
  1734.                                                 background: #313244;
  1735.                                                 border: 1px solid #45475a;
  1736.                                                 border-radius: 6px;
  1737.                                                 color: #cdd6f4;
  1738.                                                 padding: 8px 10px;
  1739.                                                 font-size: 14px;
  1740.                                                 transition: border-color 0.3s;
  1741.                                             }
  1742.  
  1743.                                             .select-input:focus {
  1744.                                                 outline: none;
  1745.                                                 border-color: #89b4fa;
  1746.                                             }
  1747.                                         `;
  1748.                                         document.head.appendChild(extraStyles);
  1749.  
  1750.                                         // Load saved settings before applying them to the UI
  1751.                                         myFunctions.loadSettings();
  1752.  
  1753.                                         // Apply loaded settings to UI controls
  1754.                                         $('#autoRun').prop('checked', myVars.autoRun);
  1755.                                         $('#autoMove').prop('checked', myVars.autoMove);
  1756.  
  1757.                                         $('#depthSlider').val(lastValue);
  1758.                                         $('#depthValue').text(lastValue);
  1759.                                         $('#depthText').html("Current Depth: <strong>" + lastValue + "</strong>");
  1760.  
  1761.                                         if (myVars.highlightColor) {
  1762.                                             $('#highlightColor').val(myVars.highlightColor);
  1763.                                         }
  1764.  
  1765.                                         // Update the play style sliders with saved values
  1766.                                         if (myVars.playStyle) {
  1767.                                             $('#aggressiveSlider').val(Math.round(((myVars.playStyle.aggressive - 0.3) / 0.5) * 10));
  1768.                                             $('#aggressiveValue').text($('#aggressiveSlider').val());
  1769.  
  1770.                                             $('#defensiveSlider').val(Math.round(((myVars.playStyle.defensive - 0.3) / 0.5) * 10));
  1771.                                             $('#defensiveValue').text($('#defensiveSlider').val());
  1772.  
  1773.                                             $('#tacticalSlider').val(Math.round(((myVars.playStyle.tactical - 0.2) / 0.6) * 10));
  1774.                                             $('#tacticalValue').text($('#tacticalSlider').val());
  1775.  
  1776.                                             $('#positionalSlider').val(Math.round(((myVars.playStyle.positional - 0.2) / 0.6) * 10));
  1777.                                             $('#positionalValue').text($('#positionalSlider').val());
  1778.                                         }
  1779.  
  1780.                                         // Update blunder rate slider with saved value
  1781.                                         if (myVars.blunderRate !== undefined) {
  1782.                                             $('#blunderRateSlider').val(Math.round(myVars.blunderRate * 10));
  1783.                                             $('#blunderRateValue').text($('#blunderRateSlider').val());
  1784.                                         }
  1785.  
  1786.                                         // Set advanced settings based on saved values
  1787.                                         $('#adaptToRating').prop('checked', myVars.adaptToRating);
  1788.                                         $('#useOpeningBook').prop('checked', myVars.useOpeningBook);
  1789.                                         $('#enableHotkeys').prop('checked', myVars.enableHotkeys);
  1790.                                         $('#randomizeTiming').prop('checked', myVars.randomizeTiming);
  1791.  
  1792.                                         if (myVars.mouseMovementRealism !== undefined) {
  1793.                                             $('#mouseMovementSlider').val(Math.round(myVars.mouseMovementRealism * 10));
  1794.                                             $('#mouseMovementSliderValue').text($('#mouseMovementSlider').val());
  1795.                                         }
  1796.  
  1797.                                         if (myVars.preferredOpenings && myVars.preferredOpenings.length === 1) {
  1798.                                             $('#preferredOpeningSelect').val(myVars.preferredOpenings[0]);
  1799.                                         }
  1800.  
  1801.                                         // Add event handlers to save settings when they change
  1802.                                         $('#autoRun, #autoMove, #adaptToRating, #useOpeningBook, #enableHotkeys, #randomizeTiming').on('change', function() {
  1803.                                             const id = $(this).attr('id');
  1804.                                             myVars[id] = $(this).prop('checked');
  1805.                                             myFunctions.saveSettings();
  1806.                                         });
  1807.  
  1808.                                         $('#depthSlider').on('input', function() {
  1809.                                             // The existing handler already updates the UI
  1810.                                             myFunctions.saveSettings();
  1811.                                         });
  1812.  
  1813.                                         $('#timeDelayMin, #timeDelayMax').on('change', function() {
  1814.                                             myFunctions.saveSettings();
  1815.                                         });
  1816.  
  1817.                                         $('.style-slider').on('input', function() {
  1818.                                             // The existing handler updates the playStyle object
  1819.                                             myFunctions.saveSettings();
  1820.                                         });
  1821.  
  1822.                                         $('#highlightColor').on('input', function() {
  1823.                                             // Existing handler already updates myVars.highlightColor
  1824.                                             myFunctions.saveSettings();
  1825.                                         });
  1826.  
  1827.                                         $('#preferredOpeningSelect').on('change', function() {
  1828.                                             // Existing handler updates preferredOpenings
  1829.                                             myFunctions.saveSettings();
  1830.                                         });
  1831.  
  1832.                                         $('#playingProfileSelect').on('change', function() {
  1833.                                             // After profile is applied
  1834.                                             setTimeout(myFunctions.saveSettings, 100);
  1835.                                         });
  1836.  
  1837.                                         $('#autoMove').on('change', function() {
  1838.                                             myVars.autoMove = $(this).prop('checked');
  1839.                                             console.log(`Auto move set to: ${myVars.autoMove}`);
  1840.                                             myFunctions.saveSettings();
  1841.                                         });
  1842.  
  1843.                                         loaded = true;
  1844.         } catch (error) {console.log(error)}
  1845.     }
  1846.  
  1847.  
  1848.     function other(delay) {
  1849.         // Create more natural timing pattern based on game situation
  1850.         const gamePhase = estimateGamePhase();
  1851.         const positionComplexity = estimatePositionComplexity();
  1852.  
  1853.         // Apply more realistic timing adjustments
  1854.         let naturalDelay = delay;
  1855.  
  1856.         // Faster moves in openings
  1857.         if (gamePhase < 10) {
  1858.             naturalDelay *= (0.6 + Math.random() * 0.4);
  1859.         }
  1860.  
  1861.         // Slower in complex positions
  1862.         if (positionComplexity > 0.7) {
  1863.             naturalDelay *= (1 + Math.random() * 1.5);
  1864.         }
  1865.  
  1866.         // Add slight additional randomness
  1867.         naturalDelay *= (0.85 + Math.random() * 0.3);
  1868.  
  1869.         var endTime = Date.now() + naturalDelay;
  1870.         var timer = setInterval(()=>{
  1871.             if(Date.now() >= endTime){
  1872.                 myFunctions.autoRun(getAdjustedDepth());
  1873.                 canGo = true;
  1874.                 clearInterval(timer);
  1875.             }
  1876.         },10);
  1877.     }
  1878.  
  1879.     function getAdjustedDepth() {
  1880.         // Get time remaining and adjust depth accordingly
  1881.         const timeRemaining = estimateTimeRemaining();
  1882.         const gamePhase = estimateGamePhase();
  1883.         const positionType = analyzePositionType(board.game.getFEN());
  1884.         const isPositionCritical = isPositionCriticalNow();
  1885.         
  1886.         // Base depth from slider
  1887.         let baseDepth = lastValue;
  1888.         
  1889.         // Time-based adjustments
  1890.         if (timeRemaining < 30) {
  1891.             // Below 30 seconds - use very low depth
  1892.             return Math.floor(Math.random() * 3) + 1; // 1-3
  1893.         } else if (timeRemaining < 60) {
  1894.             // Below 1 minute - use low depth
  1895.             return Math.floor(Math.random() * 3) + 5; // 5-7
  1896.         }
  1897.         
  1898.         // Game phase adjustments
  1899.         if (gamePhase < 10) {
  1900.             // Opening phase - use lower depth
  1901.             baseDepth = Math.min(baseDepth, 10);
  1902.         } else if (gamePhase > 30) {
  1903.             // Endgame - can use higher depth as positions are simpler
  1904.             baseDepth = Math.min(baseDepth + 2, 20);
  1905.         }
  1906.         
  1907.         // Occasionally use very low depth to prevent detection
  1908.         if (!isPositionCritical && Math.random() < 0.15) {
  1909.             return Math.floor(Math.random() * 2) + 2; // 2-3
  1910.         }
  1911.         
  1912.         // Add some randomness to the depth
  1913.         const variation = Math.floor(Math.random() * 5) - 2; // -2 to +2
  1914.         return Math.max(1, Math.min(20, baseDepth + variation));
  1915.     }
  1916.  
  1917.     function isPositionCriticalNow() {
  1918.         // Determine if the current position is critical
  1919.         // This is a simplified implementation
  1920.         try {
  1921.             // Check if kings are under attack
  1922.             const inCheck = board.game.inCheck();
  1923.             
  1924.             // Check material balance (simplified)
  1925.             const fen = board.game.getFEN();
  1926.             const whiteMaterial = countMaterial(fen, true);
  1927.             const blackMaterial = countMaterial(fen, false);
  1928.             const materialDifference = Math.abs(whiteMaterial - blackMaterial);
  1929.             
  1930.             // Position is critical if in check or material is close
  1931.             return inCheck || materialDifference < 2;
  1932.         } catch (e) {
  1933.             return false;
  1934.         }
  1935.     }
  1936.  
  1937.     function countMaterial(fen, isWhite) {
  1938.         // Simple material counting function
  1939.         const position = fen.split(' ')[0];
  1940.         let material = 0;
  1941.         
  1942.         const pieces = isWhite ? 'PNBRQK' : 'pnbrqk';
  1943.         const values = { 'P': 1, 'N': 3, 'B': 3, 'R': 5, 'Q': 9, 'K': 0, 
  1944.                          'p': 1, 'n': 3, 'b': 3, 'r': 5, 'q': 9, 'k': 0 };
  1945.         
  1946.         for (let char of position) {
  1947.             if (pieces.includes(char)) {
  1948.                 material += values[char];
  1949.             }
  1950.         }
  1951.         
  1952.         return material;
  1953.     }
  1954.  
  1955.     async function getVersion(){
  1956.         var GF = new GreasyFork; // set upping api
  1957.         var code = await GF.get().script().code(531100); // Get code
  1958.         var version = GF.parseScriptCodeMeta(code).filter(e => e.meta === '@version')[0].value; // filtering array and getting value of @version
  1959.  
  1960.         if(currentVersion !== version){
  1961.             while(true){
  1962.                 alert('UPDATE THIS SCRIPT IN ORDER TO PROCEED!');
  1963.             }
  1964.         }
  1965.     }
  1966.  
  1967.     //Removed due to script being reported. I tried to make it so people can know when bug fixes come out. Clearly people don't like that.
  1968.     //getVersion();
  1969.  
  1970.     const waitForChessBoard = setInterval(() => {
  1971.         if(loaded) {
  1972.             board = $('chess-board')[0] || $('wc-chess-board')[0];
  1973.             myVars.autoRun = $('#autoRun')[0].checked;
  1974.             myVars.autoMove = $('#autoMove')[0].checked;
  1975.             let minDel = parseFloat($('#timeDelayMin')[0].value);
  1976.             let maxDel = parseFloat($('#timeDelayMax')[0].value);
  1977.             myVars.delay = Math.random() * (maxDel - minDel) + minDel;
  1978.             myVars.isThinking = isThinking;
  1979.             myFunctions.spinner();
  1980.             if(board.game.getTurn() == board.game.getPlayingAs()){myTurn = true;} else {myTurn = false;}
  1981.             $('#depthText')[0].innerHTML = "Current Depth: <strong>"+lastValue+"</strong>";
  1982.         } else {
  1983.             myFunctions.loadEx();
  1984.         }
  1985.  
  1986.  
  1987.         if(!engine.engine){
  1988.             myFunctions.loadChessEngine();
  1989.         }
  1990.         if(myVars.autoRun == true && canGo == true && isThinking == false && myTurn){
  1991.             //console.log(`going: ${canGo} ${isThinking} ${myTurn}`);
  1992.             canGo = false;
  1993.             var currentDelay = myVars.delay != undefined ? myVars.delay * 1000 : 10;
  1994.             other(currentDelay);
  1995.         }
  1996.     }, 100);
  1997.  
  1998.     // Add these two functions for saving and loading settings
  1999.     myFunctions.saveSettings = function() {
  2000.         GM_setValue('autoRun', myVars.autoRun);
  2001.         GM_setValue('autoMove', myVars.autoMove);
  2002.         GM_setValue('timeDelayMin', $('#timeDelayMin').val());
  2003.         GM_setValue('timeDelayMax', $('#timeDelayMax').val());
  2004.         GM_setValue('depthValue', lastValue);
  2005.         GM_setValue('highlightColor', myVars.highlightColor);
  2006.         GM_setValue('playStyle', myVars.playStyle);
  2007.         GM_setValue('blunderRate', myVars.blunderRate);
  2008.         GM_setValue('adaptToRating', myVars.adaptToRating);
  2009.         GM_setValue('useOpeningBook', myVars.useOpeningBook);
  2010.         GM_setValue('preferredOpenings', myVars.preferredOpenings);
  2011.         GM_setValue('enableHotkeys', myVars.enableHotkeys);
  2012.         GM_setValue('randomizeTiming', myVars.randomizeTiming);
  2013.         GM_setValue('mouseMovementRealism', myVars.mouseMovementRealism);
  2014.         myFunctions.saveGameMemory(result, opponent, mistakes);
  2015.         myVars.openingRepertoire = GM_getValue('openingRepertoire', {
  2016.             white: {
  2017.                 main: getRandomOpenings(2),
  2018.                 experimental: getRandomOpenings(3, true),
  2019.                 success: {}
  2020.             },
  2021.             black: {
  2022.                 responses: {
  2023.                     e4: getRandomResponses('e4', 2),
  2024.                     d4: getRandomResponses('d4', 2),
  2025.                     c4: getRandomResponses('c4', 2),
  2026.                     other: getRandomResponses('other', 2)
  2027.                 },
  2028.                 success: {}
  2029.             },
  2030.             lastUpdated: Date.now()
  2031.         });
  2032.         updateOpeningRepertoire();
  2033.     };
  2034.  
  2035.     myFunctions.loadSettings = function() {
  2036.         myVars.autoRun = GM_getValue('autoRun', false);
  2037.         myVars.autoMove = GM_getValue('autoMove', false);
  2038.         $('#timeDelayMin').val(GM_getValue('timeDelayMin', 0.1));
  2039.         $('#timeDelayMax').val(GM_getValue('timeDelayMax', 1));
  2040.         lastValue = GM_getValue('depthValue', 11);
  2041.         myVars.highlightColor = GM_getValue('highlightColor', 'rgb(235, 97, 80)');
  2042.         myVars.playStyle = GM_getValue('playStyle', {
  2043.             aggressive: Math.random() * 0.5 + 0.3,
  2044.             defensive: Math.random() * 0.5 + 0.3,
  2045.             tactical: Math.random() * 0.6 + 0.2,
  2046.             positional: Math.random() * 0.6 + 0.2
  2047.         });
  2048.         myVars.blunderRate = GM_getValue('blunderRate', 0.05);
  2049.         myVars.adaptToRating = GM_getValue('adaptToRating', true);
  2050.         myVars.useOpeningBook = GM_getValue('useOpeningBook', true);
  2051.         myVars.preferredOpenings = GM_getValue('preferredOpenings', ["e4", "d4", "c4", "Nf3"]);
  2052.         myVars.enableHotkeys = GM_getValue('enableHotkeys', true);
  2053.         myVars.randomizeTiming = GM_getValue('randomizeTiming', true);
  2054.         myVars.mouseMovementRealism = GM_getValue('mouseMovementRealism', 0.7);
  2055.     };
  2056.  
  2057.     myFunctions.saveGameMemory = function(result, opponent, mistakes) {
  2058.         // Get existing memory
  2059.         let gameMemory = GM_getValue('gameMemory', {
  2060.             openingSuccess: {},
  2061.             opponentHistory: {},
  2062.             mistakePositions: []
  2063.         });
  2064.  
  2065.         // Store opening success rate
  2066.         const opening = board.game.pgn.split('\n\n')[1].split(' ').slice(0, 6).join(' ');
  2067.         if (!gameMemory.openingSuccess[opening]) {
  2068.             gameMemory.openingSuccess[opening] = { wins: 0, losses: 0, draws: 0 };
  2069.         }
  2070.         gameMemory.openingSuccess[opening][result]++;
  2071.  
  2072.         // Record opponent data
  2073.         if (!gameMemory.opponentHistory[opponent]) {
  2074.             gameMemory.opponentHistory[opponent] = { games: 0, style: 'unknown' };
  2075.         }
  2076.         gameMemory.opponentHistory[opponent].games++;
  2077.  
  2078.         // Store mistake patterns for future reference
  2079.         if (mistakes && mistakes.length) {
  2080.             gameMemory.mistakePositions = gameMemory.mistakePositions.concat(mistakes).slice(-50);
  2081.         }
  2082.  
  2083.         GM_setValue('gameMemory', gameMemory);
  2084.     };
  2085.  
  2086.     function getThinkingTime(position) {
  2087.         const baseTime = parseFloat($('#timeDelayMin').val()) * 1000;
  2088.         const maxTime = parseFloat($('#timeDelayMax').val()) * 1000;
  2089.  
  2090.         // Analyze position
  2091.         const complexity = calculatePositionComplexity(position); // 0-1
  2092.         const criticalness = determinePositionCriticalness(position); // 0-1
  2093.         const familiarity = assessPositionFamiliarity(position); // 0-1
  2094.  
  2095.         // Human-like time scaling
  2096.         let thinkingTime = baseTime;
  2097.  
  2098.         // Complex positions take more time
  2099.         thinkingTime += complexity * (maxTime - baseTime) * 0.7;
  2100.  
  2101.         // Critical positions deserve more attention
  2102.         thinkingTime += criticalness * (maxTime - baseTime) * 0.5;
  2103.  
  2104.         // Unfamiliar positions need more thought
  2105.         thinkingTime += (1 - familiarity) * (maxTime - baseTime) * 0.3;
  2106.  
  2107.         // Avoid predictable timing with small random variation
  2108.         thinkingTime *= 0.85 + Math.random() * 0.3;
  2109.  
  2110.         return Math.min(maxTime * 1.2, thinkingTime);
  2111.     }
  2112.  
  2113.     // Add placeholder functions that can be expanded
  2114.     function calculatePositionComplexity(position) {
  2115.         // Count material, tension, possible tactics
  2116.         const pieceCount = position.split(/[prnbqkPRNBQK]/).length - 1;
  2117.         const hasQueen = position.includes('q') || position.includes('Q');
  2118.         const pawnStructure = analyzeBasicPawnStructure(position);
  2119.  
  2120.         return Math.min(1, (pieceCount / 32) + (hasQueen ? 0.2 : 0) + pawnStructure * 0.3);
  2121.     }
  2122.  
  2123.     function adjustEngineEvaluation(position, move, evaluation) {
  2124.         // Apply player's strategic preferences
  2125.         const adjustedEval = { ...evaluation };
  2126.  
  2127.         // Adjust based on fingerprint
  2128.         if (myVars.playerFingerprint.favoredPieces === 'knights' && move.includes('N')) {
  2129.             adjustedEval.score += 0.05 + Math.random() * 0.1;
  2130.         }
  2131.  
  2132.         if (myVars.playerFingerprint.favoredPieces === 'bishops' && move.includes('B')) {
  2133.             adjustedEval.score += 0.05 + Math.random() * 0.1;
  2134.         }
  2135.  
  2136.         // Kingside/queenside attack preference
  2137.         if (myVars.playerFingerprint.attackingStyle === 'kingside' && isKingsideMove(move)) {
  2138.             adjustedEval.score += 0.07 + Math.random() * 0.08;
  2139.         }
  2140.  
  2141.         // Occasionally have a "brilliant" insight (1-2% of moves)
  2142.         if (Math.random() < 0.015) {
  2143.             // Temporary increase in effective depth for this move evaluation
  2144.             console.log("Brilliant insight detected!");
  2145.             return getDeepEvaluation(position, move);
  2146.         }
  2147.  
  2148.         return adjustedEval;
  2149.     }
  2150.  
  2151.     function isEndgame(position) {
  2152.         // Basic endgame detection
  2153.         const pieceCount = position.split(/[prnbqkPRNBQK]/).length - 1;
  2154.         return pieceCount <= 10;
  2155.     }
  2156.  
  2157.     function adjustEndgamePlay(fen, moves) {
  2158.         if (!isEndgame(fen)) return moves;
  2159.  
  2160.         // Common human endgame patterns
  2161.         const hasKingActivity = increasesKingActivity(moves[0], fen);
  2162.         const promotionPotential = evaluatePromotionPotential(fen);
  2163.  
  2164.         // King opposition knowledge (common human knowledge)
  2165.         if (hasKingOpposition(fen) && Math.random() < 0.9) {
  2166.             // Humans typically understand king opposition
  2167.             return prioritizeOppositionMoves(moves);
  2168.         }
  2169.  
  2170.         // Activate king in endgames (humans know this)
  2171.         if (hasKingActivity && Math.random() < 0.75) {
  2172.             return moves; // Keep the engine's correct evaluation
  2173.         } else if (hasKingActivity) {
  2174.             // Sometimes miss the importance of king activity
  2175.             return [moves[1] || moves[0], ...moves.slice(1)];
  2176.         }
  2177.  
  2178.         // Humans tend to focus on pawn promotion
  2179.         if (promotionPotential > 0.7) {
  2180.             return prioritizePawnAdvancement(moves);
  2181.         }
  2182.  
  2183.         return moves;
  2184.     }
  2185.  
  2186.     // Add to myVars at initialization
  2187.     myVars.psychologicalState = {
  2188.         confidence: 0.7 + Math.random() * 0.3,  // 0.7-1.0
  2189.         tiltFactor: 0,                         // 0-1, increases with blunders
  2190.         focus: 0.8 + Math.random() * 0.2,      // 0.8-1.0, decreases with time
  2191.         playTime: 0                            // tracks continuous play time
  2192.     };
  2193.  
  2194.     // Update in a function that runs periodically
  2195.     function updatePsychologicalState(gameState) {
  2196.         // Increase play time
  2197.         myVars.psychologicalState.playTime += 1;
  2198.  
  2199.         // Focus decreases with time (mental fatigue)
  2200.         if (myVars.psychologicalState.playTime > 10) {
  2201.             myVars.psychologicalState.focus = Math.max(0.5,
  2202.                 myVars.psychologicalState.focus - 0.01);
  2203.         }
  2204.  
  2205.         // Check for blunders in recent moves
  2206.         if (detectBlunder(gameState)) {
  2207.             // Increase tilt after mistakes
  2208.             myVars.psychologicalState.tiltFactor = Math.min(1,
  2209.                 myVars.psychologicalState.tiltFactor + 0.25);
  2210.             myVars.psychologicalState.confidence = Math.max(0.3,
  2211.                 myVars.psychologicalState.confidence - 0.15);
  2212.         }
  2213.  
  2214.         // Good moves restore confidence
  2215.         if (detectGoodMove(gameState)) {
  2216.             myVars.psychologicalState.confidence = Math.min(1,
  2217.                 myVars.psychologicalState.confidence + 0.05);
  2218.             myVars.psychologicalState.tiltFactor = Math.max(0,
  2219.                 myVars.psychologicalState.tiltFactor - 0.1);
  2220.         }
  2221.  
  2222.         // Apply psychological state to blunder rate
  2223.         const effectiveBlunderRate = myVars.blunderRate *
  2224.             (1 + myVars.psychologicalState.tiltFactor) *
  2225.             (2 - myVars.psychologicalState.focus);
  2226.  
  2227.         return effectiveBlunderRate;
  2228.     }
  2229.  
  2230.     function detectTimeControl() {
  2231.         try {
  2232.             // Look for the clock element and determine time control
  2233.             const clockEl = document.querySelector('.clock-component');
  2234.             if (clockEl) {
  2235.                 const timeText = clockEl.textContent;
  2236.                 const minutes = parseInt(timeText.split(':')[0]);
  2237.  
  2238.                 if (minutes >= 15) return 'classical';
  2239.                 if (minutes >= 5) return 'rapid';
  2240.                 return 'blitz';
  2241.             }
  2242.         } catch (e) {}
  2243.  
  2244.         return 'rapid'; // Default
  2245.     }
  2246.  
  2247.     function adaptToTimeControl() {
  2248.         const timeControl = detectTimeControl();
  2249.  
  2250.         switch (timeControl) {
  2251.             case 'blitz':
  2252.                 // More intuitive play, faster moves, higher blunder rate
  2253.                 myVars.blunderRate *= 1.3;
  2254.                 $('#timeDelayMin').val(Math.max(0.1, parseFloat($('#timeDelayMin').val()) * 0.7));
  2255.                 $('#timeDelayMax').val(Math.max(0.3, parseFloat($('#timeDelayMax').val()) * 0.7));
  2256.                 // Use more recognizable patterns and opening theory
  2257.                 myVars.patternRecognitionWeight = 0.8;
  2258.                 break;
  2259.  
  2260.             case 'rapid':
  2261.                 // Balanced approach
  2262.                 myVars.patternRecognitionWeight = 0.6;
  2263.                 break;
  2264.  
  2265.             case 'classical':
  2266.                 // More calculation, deeper search, fewer blunders
  2267.                 myVars.blunderRate *= 0.7;
  2268.                 $('#timeDelayMin').val(parseFloat($('#timeDelayMin').val()) * 1.2);
  2269.                 $('#timeDelayMax').val(parseFloat($('#timeDelayMax').val()) * 1.3);
  2270.                 // More unique moves, less reliance on patterns
  2271.                 myVars.patternRecognitionWeight = 0.4;
  2272.                 break;
  2273.         }
  2274.     }
  2275.  
  2276.     function updateOpeningRepertoire() {
  2277.         // Only update periodically (simulating a player learning new openings)
  2278.         if (Date.now() - myVars.openingRepertoire.lastUpdated < 7 * 24 * 60 * 60 * 1000) {
  2279.             return; // Only update weekly
  2280.         }
  2281.  
  2282.         // Replace worst performing opening with a new one
  2283.         const gameMemory = GM_getValue('gameMemory', { openingSuccess: {} });
  2284.  
  2285.         // Find worst performing opening
  2286.         let worstScore = Infinity;
  2287.         let worstOpening = null;
  2288.  
  2289.         for (const opening in gameMemory.openingSuccess) {
  2290.             const stats = gameMemory.openingSuccess[opening];
  2291.             const score = stats.wins - stats.losses;
  2292.  
  2293.             if (score < worstScore && stats.wins + stats.losses + stats.draws >= 5) {
  2294.                 worstScore = score;
  2295.                 worstOpening = opening;
  2296.             }
  2297.         }
  2298.  
  2299.         // Replace it if we found a bad one
  2300.         if (worstOpening && worstScore < 0) {
  2301.             console.log("Phasing out unprofitable opening: " + worstOpening);
  2302.             // Replace with a new experimental opening
  2303.             if (worstOpening.startsWith('1.')) {
  2304.                 // It's a white opening
  2305.                 myVars.openingRepertoire.white.experimental =
  2306.                     myVars.openingRepertoire.white.experimental.filter(o => o !== worstOpening);
  2307.                 myVars.openingRepertoire.white.experimental.push(getRandomOpenings(1, true)[0]);
  2308.             } else {
  2309.                 // It's a black response
  2310.                 // Implementation would be similar to white
  2311.             }
  2312.         }
  2313.  
  2314.         myVars.openingRepertoire.lastUpdated = Date.now();
  2315.         GM_setValue('openingRepertoire', myVars.openingRepertoire);
  2316.     }
  2317.  
  2318.     // Then when evaluating positions:
  2319.     function adjustForTacticalProfile(moves, position) {
  2320.         for (let i = 0; i < moves.length; i++) {
  2321.             const tacticalMotif = identifyTacticalMotif(moves[i], position);
  2322.  
  2323.             // Boost strengths
  2324.             if (myVars.tacticalProfile.strengths.includes(tacticalMotif)) {
  2325.                 // Higher chance of finding this tactic
  2326.                 if (i > 0 && Math.random() < 0.8) {
  2327.                     // Swap with the first move (more likely to be played)
  2328.                     [moves[0], moves[i]] = [moves[i], moves[0]];
  2329.                 }
  2330.             }
  2331.  
  2332.             // Miss weaknesses
  2333.             if (myVars.tacticalProfile.weaknesses.includes(tacticalMotif)) {
  2334.                 // Higher chance of missing this tactic
  2335.                 if (i === 0 && moves.length > 1 && Math.random() < 0.7) {
  2336.                     // Swap with the second move (less likely to be played)
  2337.                     [moves[0], moves[1]] = [moves[1], moves[0]];
  2338.                 }
  2339.             }
  2340.         }
  2341.  
  2342.         return moves;
  2343.     }
  2344. }
  2345.  
  2346. //Touching below may break the script
  2347.  
  2348. var isThinking = false
  2349. var canGo = true;
  2350. var myTurn = false;
  2351. var board;
  2352.  
  2353.  
  2354. window.addEventListener("load", (event) => {
  2355.     let currentTime = Date.now();
  2356.     main();
  2357. });
  2358.  
  2359. function getAppropriateDepth() {
  2360.     // Get player's rating if available
  2361.     let playerRating = 1500; // Default
  2362.     try {
  2363.         const ratingEl = document.querySelector('.user-tagline-rating');
  2364.         if (ratingEl) {
  2365.             playerRating = parseInt(ratingEl.textContent);
  2366.         }
  2367.     } catch (e) {}
  2368.  
  2369.     // Map ratings to appropriate depths
  2370.     if (playerRating < 800) return Math.floor(Math.random() * 3) + 1;     // 1-3
  2371.     if (playerRating < 1200) return Math.floor(Math.random() * 3) + 3;    // 3-5
  2372.     if (playerRating < 1600) return Math.floor(Math.random() * 3) + 5;    // 5-7
  2373.     if (playerRating < 2000) return Math.floor(Math.random() * 3) + 7;    // 7-9
  2374.     if (playerRating < 2400) return Math.floor(Math.random() * 4) + 9;    // 9-12
  2375.     return Math.floor(Math.random() * 5) + 12;                           // 12-16
  2376. }
  2377.  
  2378. function getBezierPoint(t, p0, p1, p2, p3) {
  2379.     const cX = 3 * (p1.x - p0.x);
  2380.     const bX = 3 * (p2.x - p1.x) - cX;
  2381.     const aX = p3.x - p0.x - cX - bX;
  2382.     
  2383.     const cY = 3 * (p1.y - p0.y);
  2384.     const bY = 3 * (p2.y - p1.y) - cY;
  2385.     const aY = p3.y - p0.y - cY - bY;
  2386.     
  2387.     const x = (aX * Math.pow(t, 3)) + (bX * Math.pow(t, 2)) + (cX * t) + p0.x;
  2388.     const y = (aY * Math.pow(t, 3)) + (bY * Math.pow(t, 2)) + (cY * t) + p0.y;
  2389.     
  2390.     return { x, y };
  2391. }
  2392.  
  2393. function executeMouseMovement(points, index, delay, callback) {
  2394.     if (index >= points.length) {
  2395.         if (callback) callback();
  2396.         return;
  2397.     }
  2398.     
  2399.     // Simulate mouse movement
  2400.     const point = points[index];
  2401.     
  2402.     // In a real implementation, you would trigger actual mouse events
  2403.     // For our purposes, we'll just move to the next point
  2404.     setTimeout(() => {
  2405.         executeMouseMovement(points, index + 1, delay, callback);
  2406.     }, delay);
  2407. }
  2408.  
  2409. function getSquarePosition(square) {
  2410.     // Convert chess notation (e.g., "e4") to screen coordinates
  2411.     // This is a simplified version - in reality, you'd need to get actual board coordinates
  2412.     const file = square.charCodeAt(0) - 'a'.charCodeAt(0);
  2413.     const rank = parseInt(square.charAt(1)) - 1;
  2414.     
  2415.     // Get board dimensions
  2416.     const boardRect = board.getBoundingClientRect();
  2417.     const squareSize = boardRect.width / 8;
  2418.     
  2419.     // Calculate center of the square
  2420.     const x = boardRect.left + (file + 0.5) * squareSize;
  2421.     const y = boardRect.top + (7 - rank + 0.5) * squareSize;
  2422.     
  2423.     return { x, y };
  2424. }