☰

Chess.com Panel Pro by Akashdeep

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-28 提交的版本，查看 最新版本。

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