圈圈之地

代码： 全选

/**
 * Advanced: Derives coordinates from FEN and English notation (supports handling ambiguity for multiple pawns)
 * Supported formats: C2=5, +2=3, =P+1, 3P=9, etc.
 */
function deriveCoordsFromEN(fen, moveEN) {
    if (!moveEN) return null;

    // 1. Parse FEN to get the board array and the current turn
    const parts = fen.split(' ');
    const isRed = (parts[1] === 'w');
    const board = parseFENToBoard(parts[0]); // Convert to 10x9 array

    // 2. Parse English move string
    // Format parsing: [prefix?][piece/col?][action][target value]
    const match = moveEN.match(/^([+\-=1-9])?([a-zA-Z1-9])?([+\-=])(\d)$/);
    if (!match) return null;

    let prefix = match[1];      // +, -, =, 1-9 (representing front, back, middle, or ordinal number)
    let indicator = match[2];   // Piece code (e.g., P) or starting column (e.g., 2)
    const action = match[3];    // +, -, =
    const targetVal = parseInt(match[4], 10);

    // 3. Collect all pieces of the same type belonging to the current side on the board
    let searchChar = (indicator && /[a-zA-Z]/.test(indicator)) ? 
                     (isRed ? indicator.toUpperCase() : indicator.toLowerCase()) : 
                     (isRed ? 'P' : 'p'); // Default to pawn

    let candidates = [];
    for (let y = 0; y < 10; y++) {
        for (let x = 0; x < 9; x++) {
            if (board[y][x] === searchChar) {
                candidates.push({ x, y, col: isRed ? (9 - x) : (x + 1) });
            }
        }
    }

    // 4. Filter starting piece (startX, startY) based on ambiguity rules
    let piece = null;

    // Case A: Starting column specified (e.g., "2" in C2=5 or +2=3)
    if (indicator && /[1-9]/.test(indicator)) {
        const startCol = parseInt(indicator, 10);
        let colPieces = candidates.filter(p => p.col === startCol);

        if (prefix) {
            // Handle cases like "+2=3" (front-2-move-to-3)
            sortPiecesFrontToBack(colPieces, isRed);
            const idx = parsePrefixToIndex(prefix, colPieces.length);
            piece = colPieces[idx];
        } else {
            // Handle cases like "C2=5"
            piece = colPieces[0];
        }
    } 
    // Case B: Special prefix used (e.g., =P+1 or 3P=9)
    else if (prefix) {
        // First, identify columns with multiple pieces
        let multiCols = [];
        for(let c=1; c<=9; c++) {
            if (candidates.filter(p => p.col === c).length > 1) multiCols.push(c);
        }

        if (multiCols.length > 1 && prefix !== '=') {
            // This is the "two-column pawn" rule: prefix represents "front/back", indicator represents "which column"
            // If indicator is P, we need to search all candidates
            sortPiecesFrontToBack(candidates, isRed);
            const idx = parsePrefixToIndex(prefix, candidates.length); 
            piece = candidates[idx];
        } else {
            // Single-column, multiple-piece rule (front, middle, back)
            sortPiecesFrontToBack(candidates, isRed);
            const idx = parsePrefixToIndex(prefix, candidates.length);
            piece = candidates[idx];
        }
    }

    if (!piece) return null;

    // 5. Calculate target coordinates (endX, endY)
    const startX = piece.x;
    const startY = piece.y;
    let endX = startX, endY = startY;

    if (action === '=') {
        endX = isRed ? (9 - targetVal) : (targetVal - 1);
    } else {
        const direction = isRed ? -1 : 1; // Red moves decrease Y, Black moves increase Y
        const sign = (action === '+') ? 1 : -1;
        const isJumping = ['N','B','A'].includes(searchChar.toUpperCase());

        if (isJumping) {
            endX = isRed ? (9 - targetVal) : (targetVal - 1);
            const dx = Math.abs(endX - startX);
            const dy = (searchChar.toUpperCase() === 'N') ? (dx === 1 ? 2 : 1) : (dx === 2 ? 2 : 1);
            endY = startY + (direction * sign * dy);
        } else {
            endY = startY + (direction * sign * targetVal);
        }
    }

    return { startX, startY, endX, endY };
}

/** Helper: Parse FEN into an array */
function parseFENToBoard(fenPart) {
    return fenPart.split('/').map(row => {
        let line = [];
        for (let char of row) {
            if (/\d/.test(char)) line.push(...Array(parseInt(char)).fill(null));
            else line.push(char);
        }
        return line;
    });
}

/** Helper: Sort pieces based on Xiangqi rules (from front to back) */
function sortPiecesFrontToBack(pieces, isRed) {
    // Red: Smaller Y is closer to the front
    // Black: Larger Y is closer to the front
    if (isRed) pieces.sort((a, b) => a.y - b.y);
    else pieces.sort((a, b) => b.y - a.y);
}

/** Helper: Convert prefix symbol to array index */
function parsePrefixToIndex(prefix, total) {
    if (prefix === '+') return 0; // Front
    if (prefix === '-') return total - 1; // Back
    if (prefix === '=') return 1; // Middle (assuming 3 pieces)
    if (/[1-9]/.test(prefix)) return parseInt(prefix, 10) - 1; // 1-9 ordinal
    return 0;
}