Javascript Mancala雪崩版本的Minimax：我的代码返回了一个错误的移动

// Don't use magic values, but instead define constants with meaningful names:
const STORE = { false: 13, true: 6 }; // Per player: the index of their store
const STORES = new Set(Object.values(STORE));
      // Per player: the indices of their pits 
const PITS = { false: [7, 8, 9, 10, 11, 12], true: [0, 1, 2, 3, 4, 5] };
const NUM_STONES = 48;
const GOOD_SCORE = NUM_STONES / 4 + 1; // Better score than max heuristic score
const MAX_SCORE = GOOD_SCORE + 1; // Overall best possible score

// The function increment returns a boolean that is true when the move ended with a stone 
//     in the player's store, giving them a right to an extra move.
//     The given board is mutated, so the caller can see the effect of the move in that board.
function increment(board, startPit, player) {
    const numStones = board[startPit];
    let lastPit = startPit;
    for (let i = 1; i <= board[startPit]; i++) {
        // We can use a conditional inline expression to decide to add an extra 1 or not.
        lastPit = (lastPit + 1 + (lastPit + 1 == STORE[!player])) % board.length;
        board[lastPit]++;
    }
    board[startPit] = 0;
    // There are three cases:
    if (lastPit === STORE[player]) { // Extra turn!
        return true;
    }
    if (board[lastPit] == 1) { // Normal move ended.
        return false;
    }
    // The turn is not finished yet; continue...
    return increment(board, lastPit, player);
}

function minimax(board, depth, player) {
    if (board[STORE[true]] * 2 > NUM_STONES) {
        // Maximizing player has more than half of the stones, so they won the game.
        return MAX_SCORE;
    } else if (board[STORE[false]] * 2 > NUM_STONES) {
        // Minimizing player has more than half of the stones, so they won the game.
        return -MAX_SCORE;
    } else if (board[STORE[true]] + board[STORE[false]] == NUM_STONES) {
        // All stones are in the stores, and both players have an equal amount: it's draw
        return 0;
    } else if (depth === 0) {
        // Search must stop here. Give a heuristic value:
        return Math.floor((board[STORE[true]] - board[STORE[false]]) / 2);
    }
    // Get the player's own pits that have at least one stone in it:
    const availablePits = PITS[player].filter(pit => board[pit]); 
    if (player) { // Maximizing player
        let best = { score: -Infinity };
        for (const pit of availablePits) {
            const newBoard = board.slice(); // Keep a reference to the new board
            const extraTurn = increment(newBoard, pit, player);
            const score = extraTurn ? GOOD_SCORE // We get an extra turn (good!), so we will not look deeper
                                      // Otherwise: no extra turn. Continue the recursion.
                                    : minimax(newBoard, depth - 1, false).score; // Get score component
            if (score > best.score) {
                // Only make updates when the score is better
                best = { score, pit, board: newBoard };
            }
        }
        return best; // Don't alter a global. Just return complete information: {score, pit, board}.
    } else {
        let best = { score: +Infinity };
        for (const pit of availablePits) {
            const newBoard = board.slice(); 
            const extraTurn = increment(newBoard, pit, player);
            const score = extraTurn ? -GOOD_SCORE // Minimizing user wants a negative value here!
                                    : minimax(newBoard, depth - 1, false).score;
            if (score < best.score) {
                best = { score, pit, board: newBoard };
            }
        }
        return best;
    }
}

// Minimax should *return* the information instead of setting a global variable.
const { score, pit, board } = minimax([ 
    // Layout was confusing. This seems clearer:
    5, 0, 5, 5, 5, 0,     3, 
    5, 5, 0, 5, 5, 5,     0
  ], 9, true);

console.log(`The best move is from pit ${pit}. It got score ${score}, and leads to this board: ${board}`);