let transpositionTable = [];

let leaves = 0;

let startTime = 0;

​

function minimax(board) {

  leaves = 0;

  startTime = millis();

  if (whitesMove) {

    return minFunAB(board);

  } else {

    return maxFunAB(board);

  }

}

​

function minFunAB(board, a=-Inf, b=Inf, depth=0) {

  if (depth >= maxDepth) {

    leaves++;

    return board.score;

  }

  let boards = board.generateNewBoardsWhitesTurn();

  if (typeof boards == "number") {

    leaves++;

    if (depth == 0) return board;

    return boards/depth;

  }

  if (boards.length > 1) {

    boards.sort((a, b) => a.score - b.score);

  }

  let lowestBoardNo = 0;

  let lowestScore = Inf;

  // noprotect

  for (let i = 0; i < boards.length; i++) {

    let hashedBoard = computeHash(boards[i]);

    let score;

    let hashedboards = transpositionTable.map((x) => x[0]);

    if (!hashedboards.includes(hashedBoard)) {

      score = maxFunAB(boards[i], a, b, depth + 1);

      hashedboards = transpositionTable.map((x) => x[0]);

      if (depth > 1 && !hashedboards.includes(hashedBoard)) {

        transpositionTable.push([hashedBoard, score]);

      } else if (hashedboards.includes(hashedBoard)) {

        transpositionTable[hashedboards.indexOf(hashedBoard)][1] = score;

      }

    } else if (hashedboards.includes(hashedBoard)) {

      score = transpositionTable[hashedboards.indexOf(hashedBoard)][1];

    }

    // let score = maxFunAB(boards[i], a, b, depth + 1);

    if (score < lowestScore) {

      lowestBoardNo = i;

      lowestScore = score;

    } else if (depth == 0 && score == lowestScore && random(1) < 0.3) {

      lowestBoardNo = i;

    }

    b = min(b, score);

    if (b < a) break;

  }

​

  if (depth == 0) {

    transpositionTable = [];

    evalu = lowestScore;

    console.log("leaves: "+leaves);

    console.log("searching time: "+floor(millis()-startTime)+"ms");

    return boards[lowestBoardNo];

  }

  return lowestScore;

}

​

function maxFunAB(board, a=-Inf, b=Inf, depth=0) {

  if (depth >= maxDepth) {

    leaves++;

    return board.score;

  }

  let boards = board.generateNewBoardsBlacksTurn();

  if (typeof boards == "number") {

    leaves++;

    if (depth == 0) return board;

    return boards/depth;

  }

  if (boards.length > 1) {

    boards.sort((a, b) => b.score - a.score);

  }

  let topBoardNo = 0;

  let topScore = -Inf;

  // noprotect

  for (let i = 0; i < boards.length; i++) {

    let hashedBoard = computeHash(boards[i]);

    let score;

    let hashedboards = transpositionTable.map((x) => x[0]);

    if (!hashedboards.includes(hashedBoard)) {

      score = minFunAB(boards[i], a, b, depth + 1);

      hashedboards = transpositionTable.map((x) => x[0]);

      if (depth > 1 && !hashedboards.includes(hashedBoard)) {

        transpositionTable.push([hashedBoard, score]);

      } else if (hashedboards.includes(hashedBoard)) {

        transpositionTable[hashedboards.indexOf(hashedBoard)][1] = score;

      }

    } else if (hashedboards.includes(hashedBoard)) {

      score = transpositionTable[hashedboards.indexOf(hashedBoard)][1];

    }

    // let score = minFunAB(boards[i], a, b, depth + 1);

    if (score > topScore) {

      topBoardNo = i;

      topScore = score;

    } else if (depth == 0 && score == topScore && random(1) < 0.3) {

      topBoardNo = i;

    }

    a = max(a, score);

    if (b < a) break;

  }

​

  if (depth == 0) {

    transpositionTable = [];

    evalu = topScore;

    console.log("leaves: "+leaves);

    console.log("searching time: "+floor(millis()-startTime)+"ms");

    return boards[topBoardNo];

  }

  return topScore;

}

​