Highlight squares

14/04/2025, 16:51:53
安裝腳本 ?
Wrap lines
// ==UserScript==
// @name        Highlight squares
// @namespace   Violentmonkey Scripts
// @match       https://chess.ytdraws.win/*
// @grant       none
// @version     1.0
// @author      -
// @description 14/04/2025, 16:51:53
// @license CC-NC-SA
// ==/UserScript==
// == Pathfinding & Attack Visualization Script ==
 
(function() { // Encapsulate to avoid polluting global scope too much
 
    // --- Configuration ---
    const ATTACKED_SQUARE_COLOR = 'rgba(255, 0, 0, 0.25)'; // Red, semi-transparent
    const PATH_COLOR = 'rgba(0, 0, 255, 0.3)'; // Blue, semi-transparent
    const PATH_STEP_INTERVAL_MS = 50; // How often to check if we can take the next step (doesn't override game cooldown)
    const MOVE_COOLDOWN_THRESHOLD = 220; // From original game code, ms
 
    // --- State Variables ---
    let visualizeAttacksEnabled = false;
    let attackedSquares = new Set(); // Stores "x,y" strings of attacked squares
    let pathfindingData = {
        active: false,
        pieceType: 0,
        startX: -1,
        startY: -1,
        targetX: -1,
        targetY: -1,
        currentPath: [], // Array of [x, y] steps
        pathIndex: 0,
        intervalId: null
    };
 
    // --- Attack Calculation ---
 
    /**
     * Calculates all squares attacked by enemy pieces.
     * Assumes generateLegalMoves works correctly for all piece types.
     * @returns {Set<string>} A set of "x,y" strings representing attacked squares.
     */
    function calculateAllEnemyAttacks() {
        const attacked = new Set();
        if (typeof board === 'undefined' || typeof teams === 'undefined' || typeof selfId === 'undefined' || typeof generateLegalMoves !== 'function') {
            return attacked;
        }
 
        for (let x = 0; x < boardW; x++) {
            for (let y = 0; y < boardH; y++) {
                const team = teams[x]?.[y];
                const piece = board[x]?.[y];
                // Check if it's an enemy piece (not ours, not neutral, not empty)
                if (piece && team && team !== selfId && team !== 0) {
                    try {
                        const moves = generateLegalMoves(x, y, board, teams);
                        for (const move of moves) {
                            attacked.add(`${move[0]},${move[1]}`);
                        }
                    } catch (e) {
                        // console.warn(`Error generating moves for enemy at ${x},${y}:`, e);
                    }
                }
            }
        }
        return attacked;
    }
 
    // --- Pathfinding (BFS) ---
 
    /**
     * Finds the shortest path using Breadth-First Search.
     * @param {number} startX
     * @param {number} startY
     * @param {number} targetX
     * @param {number} targetY
     * @param {number} pieceType The type of piece trying to move (for generateLegalMoves)
     * @returns {Array<Array<number>> | null} Path as array of [x,y] steps, or null if no path.
     */
    function findPathBFS(startX, startY, targetX, targetY, pieceType) {
        console.log(`Pathfinding: Type ${pieceType} from ${startX},${startY} to ${targetX},${targetY}`);
        if (typeof board === 'undefined' || typeof teams === 'undefined' || typeof selfId === 'undefined' || typeof generateLegalMoves !== 'function') {
            console.error("Pathfinding failed: Missing game variables or functions.");
            return null;
        }
 
        const queue = [[startX, startY]];
        const visited = new Set([`${startX},${startY}`]);
        const parentMap = {}; // Store "childX,childY": [parentX, parentY]
 
        while (queue.length > 0) {
            const [currX, currY] = queue.shift();
 
            // Target found?
            if (currX === targetX && currY === targetY) {
                // Reconstruct path
                const path = [];
                let step = [targetX, targetY];
                while (step[0] !== startX || step[1] !== startY) {
                    path.push(step);
                    const parentKey = `${step[0]},${step[1]}`;
                    if (!parentMap[parentKey]) break; // Should not happen if target found
                    step = parentMap[parentKey];
                }
                path.push([startX, startY]); // Add start
                console.log("Path found:", path.reverse()); // Reverse to get start -> end
                return path;
            }
 
            // Get legal moves *as if* the piece were at currX, currY
            // We need a way to call generateLegalMoves assuming the piece *type*
            // is at currX, currY, temporarily ignoring the actual board state there
            // for planning purposes, *except* for blocking friendly pieces.
            // This requires modifying generateLegalMoves or having a variant.
            // --- SIMPLIFICATION for this example: ---
            // We'll call generateLegalMoves normally. This means it might fail if
            // the intermediate square is occupied inappropriately for the real piece.
            // A more robust solution needs a planning-specific move generator.
            // We also *simulate* the piece being there to check moves.
            const originalPiece = board[currX]?.[currY];
            const originalTeam = teams[currX]?.[currY];
            board[currX][currY] = pieceType; // Temporarily place piece for move generation
            teams[currX][currY] = selfId;
            let legalMoves = [];
            try {
                 legalMoves = generateLegalMoves(currX, currY, board, teams);
            } catch (e) { /* handle error */ }
            // Restore original board state
            board[currX][currY] = originalPiece === undefined ? 0 : originalPiece;
            teams[currX][currY] = originalTeam === undefined ? 0 : originalTeam;
            // --- End Simplification ---
 
 
            for (const move of legalMoves) {
                const [nextX, nextY] = move;
                const nextKey = `${nextX},${nextY}`;
 
                // Check bounds and if already visited
                if (nextX < 0 || nextX >= boardW || nextY < 0 || nextY >= boardH || visited.has(nextKey)) {
                    continue;
                }
 
                // Check if destination is blocked by a friendly piece (crucial!)
                // Allow moving *to* the target square even if occupied (capture/overwrite)
                if (teams[nextX]?.[nextY] === selfId && !(nextX === targetX && nextY === targetY)) {
                    continue;
                }
 
                // Mark visited, store parent, enqueue
                visited.add(nextKey);
                parentMap[nextKey] = [currX, currY];
                queue.push([nextX, nextY]);
            }
        }
 
        console.log("Pathfinding failed: No path found.");
        return null; // No path found
    }
 
    // --- Path Execution ---
 
    function executePathStep() {
        if (!pathfindingData.active || typeof send !== 'function' || typeof curMoveCooldown === 'undefined') {
            stopPathfinding();
            return;
        }
 
        // Check game cooldown
        if (curMoveCooldown > MOVE_COOLDOWN_THRESHOLD) {
            return; // Wait for cooldown
        }
 
        // Check if path is complete
        if (pathfindingData.pathIndex >= pathfindingData.currentPath.length - 1) {
            console.log("Path complete.");
            stopPathfinding();
            return;
        }
 
        const currentStep = pathfindingData.currentPath[pathfindingData.pathIndex];
        const nextStep = pathfindingData.currentPath[pathfindingData.pathIndex + 1];
 
        console.log(`Executing path step: [${currentStep[0]}, ${currentStep[1]}] -> [${nextStep[0]}, ${nextStep[1]}]`);
 
        try {
            // Send the move for the *next* step
            const buf = new Uint16Array(4);
            buf[0] = currentStep[0]; // From
            buf[1] = currentStep[1];
            buf[2] = nextStep[0];   // To
            buf[3] = nextStep[1];
            send(buf);
 
            // Advance path index (will be used in next interval check)
            pathfindingData.pathIndex++;
             // We assume the 'send' action triggers the game's cooldown mechanism.
             // Our check of `curMoveCooldown` at the start handles waiting.
 
        } catch (e) {
            console.error("Error sending path step move:", e);
            stopPathfinding();
        }
    }
 
    function startPathfinding(targetX, targetY) {
        stopPathfinding(); // Stop any previous path
 
        if (typeof selectedSquareX === 'undefined' || typeof selectedSquareY === 'undefined') {
            console.log("Pathfinding: No piece selected.");
            return;
        }
        if (selectedSquareX === targetX && selectedSquareY === targetY) {
            console.log("Pathfinding: Target is the same as start.");
            return;
        }
         const pieceType = board[selectedSquareX]?.[selectedSquareY];
         if (!pieceType) {
             console.error("Pathfinding: Cannot determine selected piece type.");
             return;
         }
 
 
        const path = findPathBFS(selectedSquareX, selectedSquareY, targetX, targetY, pieceType);
 
        if (path && path.length > 1) { // Need at least start and one step
            pathfindingData = {
                active: true,
                pieceType: pieceType,
                startX: selectedSquareX,
                startY: selectedSquareY,
                targetX: targetX,
                targetY: targetY,
                currentPath: path,
                pathIndex: 0, // Start at the beginning of the path
                intervalId: setInterval(executePathStep, PATH_STEP_INTERVAL_MS)
            };
            console.log("Pathfinding started.");
            // Deselect piece visually maybe? Or keep selected? User choice.
            // selectedSquareX = selectedSquareY = undefined; // Optional deselect
        } else {
            console.log("Pathfinding: No valid path found or path too short.");
            // Optionally provide user feedback (e.g., flash screen red)
        }
    }
 
    function stopPathfinding() {
        if (pathfindingData.intervalId) {
            clearInterval(pathfindingData.intervalId);
        }
        pathfindingData = { active: false, intervalId: null, currentPath: [], pathIndex: 0 }; // Reset state
        console.log("Pathfinding stopped.");
    }
 
    // --- Drawing ---
 
    function drawAttackedSquares() {
        if (!visualizeAttacksEnabled || typeof ctx === 'undefined' || typeof camera === 'undefined') return;
 
        // Recalculate attacks (can be optimized)
        attackedSquares = calculateAllEnemyAttacks();
 
        if (attackedSquares.size === 0) return;
 
        const originalTransform = ctx.getTransform(); // Save original transform
        ctx.translate(canvas.width / 2, canvas.height / 2);
        ctx.scale(camera.scale, camera.scale);
        ctx.translate(camera.x, camera.y);
 
        ctx.fillStyle = ATTACKED_SQUARE_COLOR;
 
        // Get visible bounds (using canvasPos - slightly adapted)
        const topLeftView = canvasPos ? canvasPos({ x: 0, y: 0 }) : { x: -camera.x * camera.scale, y: -camera.y * camera.scale }; // Fallback if canvasPos missing
        const bottomRightView = canvasPos ? canvasPos({ x: innerWidth, y: innerHeight }) : { x: (innerWidth / camera.scale) - camera.x, y: (innerHeight / camera.scale) - camera.y }; // Fallback
 
        const startCol = Math.max(0, Math.floor(topLeftView.x / squareSize) - 1);
        const endCol = Math.min(boardW, Math.ceil(bottomRightView.x / squareSize) + 1);
        const startRow = Math.max(0, Math.floor(topLeftView.y / squareSize) - 1);
        const endRow = Math.min(boardH, Math.ceil(bottomRightView.y / squareSize) + 1);
 
 
        attackedSquares.forEach(key => {
            const [x, y] = key.split(',').map(Number);
            // Only draw if within rough view bounds
            if (x >= startCol && x < endCol && y >= startRow && y < endRow) {
                 ctx.fillRect(x * squareSize, y * squareSize, squareSize, squareSize);
            }
        });
 
        ctx.setTransform(originalTransform); // Restore original transform
    }
 
     function drawCurrentPath() {
        if (!pathfindingData.active || pathfindingData.currentPath.length === 0 || typeof ctx === 'undefined' || typeof camera === 'undefined') return;
 
        const originalTransform = ctx.getTransform();
        ctx.translate(canvas.width / 2, canvas.height / 2);
        ctx.scale(camera.scale, camera.scale);
        ctx.translate(camera.x, camera.y);
 
        ctx.fillStyle = PATH_COLOR;
        ctx.strokeStyle = 'rgba(0, 0, 150, 0.5)';
        ctx.lineWidth = 3 / camera.scale; // Make line width scale invariant
 
        // Draw path lines/squares
        for (let i = pathfindingData.pathIndex; i < pathfindingData.currentPath.length; i++) {
             const [x, y] = pathfindingData.currentPath[i];
             // Draw square highlight
             ctx.fillRect(x * squareSize, y * squareSize, squareSize, squareSize);
 
             // Draw line to next segment (optional)
             if (i < pathfindingData.currentPath.length - 1) {
                const [nextX, nextY] = pathfindingData.currentPath[i+1];
                ctx.beginPath();
                ctx.moveTo(x * squareSize + squareSize / 2, y * squareSize + squareSize / 2);
                ctx.lineTo(nextX * squareSize + squareSize / 2, nextY * squareSize + squareSize / 2);
                ctx.stroke();
             }
        }
        ctx.setTransform(originalTransform);
    }
 
 
    // --- Integration with Game Loop & Events ---
 
    // Monkey-patch the render function (use MutationObserver if render is complex/obfuscated)
    if (typeof render === 'function') {
        const originalRender = render;
        window.render = function(...args) {
            originalRender.apply(this, args); // Call original render first
            // Add our drawing functions
            try {
                drawAttackedSquares();
                drawCurrentPath();
            } catch (e) {
                 console.error("Error in visualization drawing:", e);
                 // Stop visuals if they error out?
                 visualizeAttacksEnabled = false;
                 stopPathfinding();
            }
        }
        console.log("Visualization hooks added to render function.");
    } else {
        console.error("Could not find global 'render' function to hook into.");
    }
 
    // Monkey-patch mousedown (or add event listener if preferred)
     if (typeof onmousedown === 'function') {
         const originalMouseDown = onmousedown;
         window.onmousedown = function(e) {
             // Stop any ongoing pathfinding if user clicks anywhere
             if (pathfindingData.active) {
                  console.log("User click interrupted pathfinding.");
                  stopPathfinding();
                  // Let the original handler decide if a new selection/move happens
             }
 
            // Calculate potential target square BEFORE calling original handler
             let targetX, targetY;
             let mousePosDown; // Store mouse pos for pathfinding check
             try {
                 const t = ctx.getTransform(); // Need context for transform
                 ctx.translate(canvas.width/2, canvas.height/2);
                 ctx.scale(camera.scale, camera.scale);
                 ctx.translate(camera.x, camera.y);
                 mousePosDown = canvasPos({ x: e.clientX, y: e.clientY }); // Use clientX/Y
                 ctx.setTransform(t); // Restore immediately
                 targetX = Math.floor(mousePosDown.x / squareSize);
                 targetY = Math.floor(mousePosDown.y / squareSize);
             } catch (err) {
                // console.error("Could not calculate target square on mousedown:", err);
                originalMouseDown.call(this, e); // Still call original
                return;
            }
 
            // --- Pathfinding Check ---
            let isImmediateLegalMove = false;
            if (typeof selectedSquareX !== 'undefined' && typeof selectedSquareY !== 'undefined' && typeof legalMoves !== 'undefined' && Array.isArray(legalMoves)) {
                for (let i = 0; i < legalMoves.length; i++) {
                    if (legalMoves[i][0] === targetX && legalMoves[i][1] === targetY) {
                        isImmediateLegalMove = true;
                        break;
                    }
                }
            }
 
            // Call the original handler *first* to handle selection/deselection/immediate moves
            originalMouseDown.call(this, e);
 
            // --- Initiate Pathfinding AFTER original handler ---
            // Check if:
            // 1. A piece *is still* selected (original handler didn't deselect or move successfully).
            // 2. The click was NOT an immediate legal move for the originally selected piece.
            // 3. The click is within board bounds.
            // 4. Pathfinding isn't already active (should have been stopped above, but double check).
            if (typeof selectedSquareX !== 'undefined' && typeof selectedSquareY !== 'undefined' &&
                !isImmediateLegalMove &&
                targetX >= 0 && targetX < boardW && targetY >= 0 && targetY < boardH &&
                !pathfindingData.active)
            {
                // Check cooldown just before starting pathfinding
                if (curMoveCooldown <= MOVE_COOLDOWN_THRESHOLD) {
                    console.log("Initiating pathfinding to", targetX, targetY);
                    startPathfinding(targetX, targetY);
                } else {
                    console.log("Cannot start pathfinding, move cooldown active.");
                }
            }
         }
         console.log("Pathfinding hook added to onmousedown function.");
     } else {
        console.error("Could not find global 'onmousedown' function to hook into.");
     }
 
 
    // --- Global Control Functions ---
    window.toggleAttackVisualization = function(enable = !visualizeAttacksEnabled) {
        visualizeAttacksEnabled = enable;
        console.log("Attack Visualization " + (visualizeAttacksEnabled ? "Enabled" : "Disabled"));
        if (!visualizeAttacksEnabled) {
            attackedSquares.clear(); // Clear stored squares when disabled
            // Request a redraw if possible (difficult without direct access to game loop flags)
        }
    }
 
    window.cancelCurrentPath = function() {
        stopPathfinding();
    }
 
    console.log("Pathfinding and Attack Visualization script loaded.");
    console.log("Use toggleAttackVisualization() to turn red squares on/off.");
    console.log("Click an invalid square after selecting a piece to pathfind.");
    console.log("Use cancelCurrentPath() to stop active pathfinding.");
    toggleAttackVisualization()
 
})(); // End IIFE