const PIECE_SCALE = 0.86;

/*
 * 棋盤座標使用 0 起算。
 * 中心四格為：
 * (4,4) (4,5)
 * (5,4) (5,5)
 */
const OPENING_CENTER_CELLS = Object.freeze([
  Object.freeze({ row: 4, col: 4 }),
  Object.freeze({ row: 4, col: 5 }),
  Object.freeze({ row: 5, col: 4 }),
  Object.freeze({ row: 5, col: 5 })
]);

const OPENING_CENTER_KEYS = new Set(
  OPENING_CENTER_CELLS.map(cell => `${cell.row},${cell.col}`)
);

/*
 * 法諾四種方向要佔據中心四格中的三格時，
 * 唯一合法的四個錨點。
 */
const OPENING_FINO_ANCHORS = Object.freeze({
  tl: Object.freeze({ row: 4, col: 4 }),
  tr: Object.freeze({ row: 4, col: 5 }),
  br: Object.freeze({ row: 5, col: 5 }),
  bl: Object.freeze({ row: 5, col: 4 })
});

const PIECE_ORDER = ['fino', 'mino', 'vino'];

function buildBoardGrid() {
  let pathData = '';

  for (let index = 1; index < BOARD_SIZE; index += 1) {
    const position = index * CELL_SIZE;
    pathData += `M ${position} 0 V 480 `;
    pathData += `M 0 ${position} H 480 `;
  }

  const path = document.createElementNS(SVG_NS, 'path');
  path.setAttribute('d', pathData.trim());
  path.setAttribute('class', 'grid-lines');

  els.gridLayer.replaceChildren(path);
}

function buildBoardGrid() {
  let pathData = '';

  for (let index = 1; index < BOARD_SIZE; index += 1) {
    const position = index * CELL_SIZE;

    pathData += `M ${position} 0 V 480 `;
    pathData += `M 0 ${position} H 480 `;
  }

  const normalPath = document.createElementNS(SVG_NS, 'path');
  normalPath.setAttribute('d', pathData.trim());
  normalPath.setAttribute('class', 'grid-lines');

  /*
   * 中心四格由第 4、5、6 條格線包圍：
   * x = 192、240、288
   * y = 192、240、288
   *
   * 因此總共另外繪製三條直線及三條橫線。
   */
  const centerPositions = [4, 5, 6].map(index => index * CELL_SIZE);

  let centerPathData = '';

  centerPositions.forEach(position => {
    centerPathData += `M ${position} ${4 * CELL_SIZE} V ${6 * CELL_SIZE} `;
    centerPathData += `M ${4 * CELL_SIZE} ${position} H ${6 * CELL_SIZE} `;
  });

  const centerPath = document.createElementNS(SVG_NS, 'path');
  centerPath.setAttribute('d', centerPathData.trim());
  centerPath.setAttribute('class', 'center-grid-lines');

  els.gridLayer.replaceChildren(normalPath, centerPath);
}

.opening-hint-dot {
  stroke-width: 2.4;
  vector-effect: non-scaling-stroke;
  pointer-events: none;
  transform-box: fill-box;
  transform-origin: center;
  animation: opening-hint-pulse 620ms ease-in-out infinite;
}

.opening-hint-dot.owner-1 {
  fill: var(--p1);
  stroke: var(--p1-dark);
  filter: drop-shadow(0 0 7px rgba(255, 128, 111, 0.88));
}

.opening-hint-dot.owner-2 {
  fill: var(--p2);
  stroke: var(--p2-dark);
  filter: drop-shadow(0 0 7px rgba(96, 172, 248, 0.88));
}

@keyframes opening-hint-pulse {
  0%,
  100% {
    opacity: 0.3;
    transform: scale(0.72);
  }

  50% {
    opacity: 1;
    transform: scale(1.24);
  }
}

function getRoundStarter(roundNumber = state.roundNumber) {
  return roundNumber === 1 ? 1 : 2;
}

function isStarterOpeningPlacement(player, type) {
  return (
    type === 'fino' &&
    state.gameStarted &&
    !state.roundEnded &&
    !state.gameOver &&
    state.pieces.length === 0 &&
    state.currentPlayer === player &&
    getRoundStarter() === player
  );
}

function countOpeningCenterCells(cells) {
  let count = 0;

  cells.forEach(cell => {
    if (OPENING_CENTER_KEYS.has(cellKey(cell.row, cell.col))) {
      count += 1;
    }
  });

  return count;
}

function satisfiesOpeningCenterRule(cells) {
  return countOpeningCenterCells(cells) >= 3;
}

function clearOpeningRuleHint() {
  window.clearTimeout(state.openingHintTimer);

  state.openingHintTimer = null;
  state.openingHintPlayer = 0;

  if (els.openingHintLayer) {
    els.openingHintLayer.replaceChildren();
  }
}

function showOpeningRuleHint(active, duration = 2000) {
  clearOpeningRuleHint();

  if (
    !active ||
    active.type !== 'fino' ||
    !isStarterOpeningPlacement(active.player, active.type)
  ) {
    return;
  }

  state.openingHintPlayer = active.player;
  renderOpeningRuleHint();

  state.openingHintTimer = window.setTimeout(() => {
    state.openingHintTimer = null;
    state.openingHintPlayer = 0;
    renderOpeningRuleHint();
  }, duration);
}

const overlaps = cells.some(({ row, col }) => state.board[row][col] !== null);

if (overlaps) {
  return {
    ok: false,
    reason: 'overlap',
    cells
  };
}

if (type === 'fino' || type === 'mino') {

const overlaps = cells.some(({ row, col }) => state.board[row][col] !== null);

if (overlaps) {
  return {
    ok: false,
    reason: 'overlap',
    cells
  };
}

/*
 * 每局先手的第一步必須使用法諾覆蓋中心四格中的三格。
 */
if (
  isStarterOpeningPlacement(player, type) &&
  !satisfiesOpeningCenterRule(cells)
) {
  return {
    ok: false,
    reason: 'opening-center',
    cells
  };
}

if (type === 'fino' || type === 'mino') {

function renderOpeningRuleHint() {
  els.openingHintLayer.replaceChildren();

  if (!state.openingHintPlayer) {
    return;
  }

  const active = getActivePiece();

  if (
    !active ||
    active.player !== state.openingHintPlayer ||
    active.type !== 'fino' ||
    !isStarterOpeningPlacement(active.player, active.type)
  ) {
    return;
  }

  const orientation =
    state.orientationMemory[active.player].fino || active.orientation || 'tl';

  const anchor =
    OPENING_FINO_ANCHORS[orientation] || OPENING_FINO_ANCHORS.tl;

  const dot = document.createElementNS(SVG_NS, 'circle');

  dot.setAttribute('cx', (anchor.col + 0.5) * CELL_SIZE);
  dot.setAttribute('cy', (anchor.row + 0.5) * CELL_SIZE);
  dot.setAttribute('r', 8);
  dot.setAttribute(
    'class',
    `opening-hint-dot owner-${active.player}`
  );

  els.openingHintLayer.appendChild(dot);
}

if (!validation.ok) {
  const toastKey =
    {
      bounds: 'outOfBounds',
      overlap: 'overlap',
      contact: 'ownContact'
    }[validation.reason] || 'overlap';

  showToast(toastKey);
  renderMoveArrows();
  return;
}

if (!validation.ok) {
  if (validation.reason === 'opening-center') {
    showToast('openingCenterRule', {}, 2000);
    showOpeningRuleHint(active, 2000);
    renderMoveArrows();
    return;
  }

  const toastKey =
    {
      bounds: 'outOfBounds',
      overlap: 'overlap',
      contact: 'ownContact'
    }[validation.reason] || 'overlap';

  showToast(toastKey);
  renderMoveArrows();
  return;
}

const reason = {
  bounds:
    state.lang === 'zh'
      ? '棋子超出棋盤。'
      : 'The piece extends beyond the board.',

  overlap:
    state.lang === 'zh'
      ? '棋子與其他棋子重疊。'
      : 'The piece overlaps another piece.',

  contact:
    state.lang === 'zh'
      ? '法諾或米諾與本方棋子接觸。'
      : 'The Fino or Mino touches another friendly piece.',

  'opening-center':
    state.lang === 'zh'
      ? '先手第一步的法諾必須佔據棋盤中心四格中的三格。'
      : "The first player's opening Fino must occupy three of the four central cells."
}[validation.reason];

const CELL_BITS = Array.from(
  { length: 100 },
  (_, index) => 1n << BigInt(index)
);

/*
 * 中心四格的 Bitboard：
 * 44 = row 4, col 4
 * 45 = row 4, col 5
 * 54 = row 5, col 4
 * 55 = row 5, col 5
 */
const CORE_OPENING_CENTER_MASK =
  CELL_BITS[44] |
  CELL_BITS[45] |
  CELL_BITS[54] |
  CELL_BITS[55];

const CELL_CLEAR_MASKS = CELL_BITS.map(
  bit => FULL_BOARD_MASK ^ bit
);

function isLegalPlacementMask(position, player, type, mask) {
  if (!mask) {
    return false;
  }

  const occupied = getOccupiedBits(position);

  if (mask & occupied) {
    return false;
  }

  if (type === CORE_FINO || type === CORE_MINO) {

function isLegalPlacementMask(position, player, type, mask) {
  if (!mask) {
    return false;
  }

  const occupied = getOccupiedBits(position);

  if (mask & occupied) {
    return false;
  }

  /*
   * 空棋盤上的第一個法諾必須覆蓋中心四格中的至少三格。
   */
  if (
    type === CORE_FINO &&
    occupied === 0n &&
    popcountBigInt(mask & CORE_OPENING_CENTER_MASK) < 3
  ) {
    return false;
  }

  if (type === CORE_FINO || type === CORE_MINO) {

if (requiredType === CORE_FINO || requiredType === CORE_MINO) {
  const orientationCount = requiredType === CORE_MINO ? 1 : 4;

  const ownNeighbors = neighborMask(oldOwn);

  for (let orientation = 0; orientation < orientationCount; orientation += 1) {
    for (let anchor = 0; anchor < 100; anchor += 1) {
      const mask = PLACEMENT_MASKS[requiredType][orientation][anchor];

      if (!mask || (mask & occupied) !== 0n || (mask & ownNeighbors) !== 0n) {
        continue;
      }

if (requiredType === CORE_FINO || requiredType === CORE_MINO) {
  const orientationCount = requiredType === CORE_MINO ? 1 : 4;

  const ownNeighbors = neighborMask(oldOwn);

  const isOpeningFino =
    requiredType === CORE_FINO &&
    occupied === 0n;

  for (let orientation = 0; orientation < orientationCount; orientation += 1) {
    for (let anchor = 0; anchor < 100; anchor += 1) {
      const mask = PLACEMENT_MASKS[requiredType][orientation][anchor];

      if (
        !mask ||
        (mask & occupied) !== 0n ||
        (mask & ownNeighbors) !== 0n ||
        (
          isOpeningFino &&
          popcountBigInt(mask & CORE_OPENING_CENTER_MASK) < 3
        )
      ) {
        continue;
      }

/*
 * 先手首步四種合法法諾。
 * action 與玩家無關；真正的持有者由 position.currentPlayer 決定。
 */
const CORE_OPENING_ACTIONS = Object.freeze([
  encodePlacement(CORE_FINO, 0, 44), // tl，row 4 col 4
  encodePlacement(CORE_FINO, 1, 45), // tr，row 4 col 5
  encodePlacement(CORE_FINO, 2, 55), // br，row 5 col 5
  encodePlacement(CORE_FINO, 3, 54)  // bl，row 5 col 4
]);

function isCoreOpeningTurn(position) {
  return (
    !position.terminalWinner &&
    Boolean(position.currentPlayer) &&
    getOccupiedBits(position) === 0n &&
    getCoreRequiredType(
      position,
      position.currentPlayer
    ) === CORE_FINO
  );
}

function pickRandomCoreOpeningAction(position) {
  if (!isCoreOpeningTurn(position)) {
    return null;
  }

  const player = position.currentPlayer;
  const legalActions = [];

  CORE_OPENING_ACTIONS.forEach(action => {
    const orientation = actionPlacementOrientation(action);
    const anchor = actionPlacementAnchor(action);
    const mask =
      PLACEMENT_MASKS[CORE_FINO][orientation][anchor];

    if (
      isLegalPlacementMask(
        position,
        player,
        CORE_FINO,
        mask
      )
    ) {
      legalActions.push(action);
    }
  });

  if (!legalActions.length) {
    return null;
  }

  const randomIndex = Math.floor(
    Math.random() * legalActions.length
  );

  return legalActions[randomIndex];
}

async search(
  position,
  timeBudgetMilliseconds,
  signal,
  onProgress
) {
  this.syncRoot(position);

  const startTime = performance.now();

  /*
   * timeBudgetMilliseconds 可以是固定數值，
   * 也可以是每次檢查時重新讀取的函式。
   *
   * 使用函式時，連續切換 AI 等級後，
   * 搜尋會立即採用目前等級的時限。
   */
  const readTimeBudget = () => {
    const rawValue =
      typeof timeBudgetMilliseconds === 'function'
        ? timeBudgetMilliseconds()
        : timeBudgetMilliseconds;

    const numericValue = Number(rawValue);

    return Math.max(
      1,
      Number.isFinite(numericValue)
        ? numericValue
        : 1000
    );
  };

  const progressIntervalMs = 100;
  let lastProgressTime = startTime;

  let simulations = 0;

  while (true) {
    if (signal.aborted) {
      throw createAbortError();
    }

    const nowBeforeSim = performance.now();

    if (
      nowBeforeSim - startTime >= readTimeBudget()
    ) {
      break;
    }

    this.runSimulation();
    simulations += 1;

    const now = performance.now();

    if (now - lastProgressTime >= progressIntervalMs) {
      onProgress(
        (now - startTime) / 1000,
        simulations
      );

      lastProgressTime = now;

      await yieldToBrowser();
    }
  }

  if (signal.aborted) {
    throw createAbortError();
  }

  /*
   * 極短時限下仍至少進行一次模擬，
   * 確保能選出一個行動。
   */
  if (simulations === 0) {
    this.runSimulation();
    simulations = 1;
  }

  return this.pickBestFromRoot(simulations);
}

function applyAIAction(action) {
  const player = state.currentPlayer;

  if (
    !player ||
    state.roundEnded ||
    state.gameOver
  ) {
    return false;
  }

  const kind = actionKind(action);

  if (kind === ACTION_SKIP) {
    const type = actionSkipType(action);
    const typeName = TYPE_ID_TO_NAME[type];

    if (
      !typeName ||
      !canManualSkip(player, typeName)
    ) {
      return false;
    }

    state.phaseSkipped[player][typeName] = true;
    state.hoverCell = null;
    state.selectedMinoId = null;

    preparePlayerPhase(player);
    renderAll();

    observeCommittedAction(action);
    return true;
  }

  if (kind === ACTION_PLACE) {
    const type = actionPlacementType(action);
    const orientation =
      actionPlacementOrientation(action);
    const anchor = actionPlacementAnchor(action);

    if (anchor < 0 || anchor >= 100) {
      return false;
    }

    const typeName = TYPE_ID_TO_NAME[type];

    const orientationName =
      type === CORE_MINO
        ? 'single'
        : ORIENTATION_NAMES[orientation];

    if (!typeName || !orientationName) {
      return false;
    }

    const active = getActivePiece();

    if (
      !active ||
      active.player !== player ||
      active.type !== typeName
    ) {
      return false;
    }

    const validation = validatePlacement(
      player,
      typeName,
      orientationName,
      indexRow(anchor),
      indexCol(anchor)
    );

    if (!validation.ok) {
      return false;
    }

    state.orientationMemory[player][typeName] =
      orientationName;

    active.orientation = orientationName;

    placePiece(validation, active);
    return true;
  }

  if (kind === ACTION_MOVE_VINO) {
    const from = actionMoveFrom(action);
    const to = actionMoveTo(action);
    const anchor = actionMoveAnchor(action);
    const orientation =
      actionMoveOrientation(action);

    if (
      from < 0 ||
      from >= 100 ||
      to < 0 ||
      to >= 100 ||
      anchor < 0 ||
      anchor >= 100
    ) {
      return false;
    }

    const orientationName =
      ORIENTATION_NAMES[orientation];

    if (!orientationName) {
      return false;
    }

    const active = getActivePiece();

    if (
      !active ||
      active.player !== player ||
      active.type !== 'vino'
    ) {
      return false;
    }

    let placementValidation;

    if (state.pendingMinoMove) {
      /*
       * 如果盤面本來已處於「米諾已移動，等待維諾」
       * 的中間狀態，搜尋行動必須與該移動完全一致。
       */
      const pending = state.pendingMinoMove;

      const pendingFrom = boardIndex(
        pending.from.row,
        pending.from.col
      );

      const pendingTo = boardIndex(
        pending.to.row,
        pending.to.col
      );

      if (
        pending.player !== player ||
        pendingFrom !== from ||
        pendingTo !== to
      ) {
        return false;
      }

      placementValidation = validatePlacement(
        player,
        'vino',
        orientationName,
        indexRow(anchor),
        indexCol(anchor)
      );

      if (!placementValidation.ok) {
        return false;
      }
    } else {
      const mino = findRealMinoAt(from, player);

      if (!mino) {
        return false;
      }

      const destination = {
        row: indexRow(to),
        col: indexCol(to)
      };

      /*
       * 先確認 to 確實是這個米諾的正常合法移動位置。
       */
      const legalDestinations =
        getLegalMinoDestinations(mino.id);

      if (
        !legalDestinations.has(
          cellKey(
            destination.row,
            destination.col
          )
        )
      ) {
        return false;
      }

      /*
       * 先在暫時盤面驗證維諾。
       * 驗證成功後才真正移動米諾，避免失敗時留下半手棋。
       */
      placementValidation =
        withTemporaryMinoMove(
          mino,
          destination,
          () =>
            validatePlacement(
              player,
              'vino',
              orientationName,
              indexRow(anchor),
              indexCol(anchor)
            )
        );

      if (!placementValidation.ok) {
        return false;
      }

      performNormalMinoMove(
        mino.id,
        destination
      );
    }

    state.orientationMemory[player].vino =
      orientationName;

    active.orientation = orientationName;

    placePiece(placementValidation, active);
    return true;
  }

  if (kind === ACTION_FLIGHT) {
    const from = actionMoveFrom(action);
    const to = actionMoveTo(action);

    if (
      from < 0 ||
      from >= 100 ||
      to < 0 ||
      to >= 100 ||
      state.pendingMinoMove
    ) {
      return false;
    }

    const mino = findRealMinoAt(from, player);

    if (!mino) {
      return false;
    }

    const destination = {
      row: indexRow(to),
      col: indexCol(to)
    };

    if (
      state.board[destination.row]?.[
        destination.col
      ]
    ) {
      return false;
    }

    const automaticFlight =
      isMinoFlightPhase(player);

    if (!automaticFlight) {
      const active = getActivePiece();

      if (
        !active ||
        active.type !== 'vino' ||
        piecesPlacedCount(player, 'vino') === 0
      ) {
        return false;
      }
    }

    /*
     * 能以一般米諾移動到達的格子不能作為飛子落點。
     */
    const normalDestinations =
      getLegalMinoDestinations(mino.id);

    if (
      normalDestinations.has(
        cellKey(
          destination.row,
          destination.col
        )
      )
    ) {
      return false;
    }

    attemptMinoFlight(
      mino.id,
      destination
    );

    /*
     * AI 自動接受主動飛子的確認窗口。
     */
    if (state.pendingFlight) {
      confirmPendingFlight();
    }

    return (
      state.playerEnded[player] ||
      state.roundEnded ||
      state.currentPlayer !== player
    );
  }

  return false;
}

/*
 * 用獨立緩衝區重新生成當前盤面的合法行動。
 * 不使用剛完成搜尋的 MCTS 共用 actions 緩衝區。
 */
const aiRecoveryCore = new CorePosition();
const aiRecoveryActions =
  new Int32Array(MAX_ACTIONS);
const aiRecoveryScores =
  new Float64Array(MAX_ACTIONS);

function applyBestAvailableAIAction(
  position,
  preferredAction
) {
  aiRecoveryCore.copyFrom(position);
  normalizeCorePosition(aiRecoveryCore);

  const count = generateCoreActions(
    aiRecoveryCore,
    aiRecoveryActions,
    aiRecoveryScores
  );

  if (count <= 0) {
    return null;
  }

  let preferredIndex = -1;

  if (Number.isInteger(preferredAction)) {
    for (let index = 0; index < count; index += 1) {
      if (
        aiRecoveryActions[index] ===
        preferredAction
      ) {
        preferredIndex = index;
        break;
      }
    }
  }

  /*
   * 搜尋結果仍是當前盤面的合法行動時，
   * 優先嘗試搜尋結果。
   */
  if (
    preferredIndex >= 0 &&
    applyAIAction(preferredAction)
  ) {
    return preferredAction;
  }

  /*
   * 搜尋結果過期、損壞或無法映射到真實盤面時，
   * 依目前盤面的合法行動排序逐一嘗試。
   */
  for (let index = 0; index < count; index += 1) {
    const action = aiRecoveryActions[index];

    if (
      index === preferredIndex ||
      action === preferredAction
    ) {
      continue;
    }

    if (applyAIAction(action)) {
      return action;
    }
  }

  return null;
}

async function runCurrentAITurn() {
  if (
    runtime.running ||
    runtime.applying ||
    !isCurrentTurnAI()
  ) {
    return;
  }

  /*
   * 確保真實盤面與 CorePosition 的自動階段切換一致。
   */
  preparePlayerPhase(state.currentPlayer);

  if (!isCurrentTurnAI()) {
    return;
  }

  const player = state.currentPlayer;

try {
  let result;

  const randomOpeningAction =
    pickRandomCoreOpeningAction(searchPosition);

  if (randomOpeningAction !== null) {
    /*
     * AI 控制先手首步時，從四種合法旋轉中隨機選擇。
     * 此分支位於引擎選擇之前，因此同時適用於
     * MCTS 和 Alpha-Beta 控制流程。
     */
    setThinkingView({
      kind: 'mcts',
      player,
      elapsed: 0,
      visits: 0
    });

    await yieldToBrowser();

    if (signal.aborted) {
      throw createAbortError();
    }

    result = {
      action: randomOpeningAction,
      evaluation: 0,
      winRate: 50,
      simulations: 0,
      openingRandom: true
    };
  } else if (
    shouldUseAlphaBeta(searchPosition, control)
  ) {

if (signal.aborted) {
  throw createAbortError();
}

const currentPosition = captureCorePosition();

if (
  state.currentPlayer !== player ||
  !sameCorePosition(searchPosition, currentPosition) ||
  !result ||
  !Number.isInteger(result.action)
) {
  return;
}

runtime.applying = true;

const applied = applyAIAction(result.action);

runtime.applying = false;

if (!applied) {
  mctsEngine.resetTo(captureCorePosition());

  return;
}

const totalElapsed = (performance.now() - searchStart) / 1000;

if (signal.aborted) {
  throw createAbortError();
}

const currentPosition = captureCorePosition();

/*
 * 玩家、盤面已在搜尋期間改變時，正常放棄舊結果。
 * 這種情況不是行動失效修復的範圍。
 */
if (
  state.currentPlayer !== player ||
  !sameCorePosition(
    searchPosition,
    currentPosition
  )
) {
  return;
}

const preferredAction =
  result && Number.isInteger(result.action)
    ? result.action
    : null;

runtime.applying = true;

const appliedAction =
  applyBestAvailableAIAction(
    currentPosition,
    preferredAction
  );

runtime.applying = false;

if (appliedAction === null) {
  /*
   * 理論上只要 CorePosition 還有合法行動便不會進入這裡。
   * 若真實盤面和核心盤面出現不可恢復的不一致，
   * 不再重新開始一輪完整搜尋，改成人類控制並保留盤面。
   */
  console.error(
    'AI could not apply any legal action to the current board.'
  );

  mctsEngine.resetTo(
    captureCorePosition()
  );

  controls[player].mode =
    AI_MODE_HUMAN;

  hideThinkingImmediately();
  renderAISettings();

  return;
}

const usedFallback =
  preferredAction === null ||
  appliedAction !== preferredAction;

const totalElapsed =
  (performance.now() - searchStart) / 1000;

const engineKind =
  result && Number.isFinite(result.nodes)
    ? 'alpha'
    : 'mcts';

const totalSearchCount =
  result && Number.isFinite(result.nodes)
    ? result.nodes
    : result &&
        Number.isFinite(result.simulations)
      ? result.simulations
      : undefined;

/*
 * 使用備選行動時，原搜尋結果的評估值並不屬於
 * 實際執行的行動，因此顯示中立值。
 */
const displayedEvaluation =
  !usedFallback &&
  result &&
  Number.isFinite(result.evaluation)
    ? result.evaluation
    : 0;

const displayedWinRate =
  !usedFallback &&
  result &&
  Number.isFinite(result.winRate)
    ? result.winRate
    : 50;

showThinkingFinal(
  player,
  totalElapsed,
  displayedEvaluation,
  displayedWinRate,
  totalSearchCount,
  engineKind
);

runtime.applying = true;

const applied = applyAIAction(forced.action);

runtime.applying = false;

if (applied) {
  const totalElapsed = (performance.now() - searchStart) / 1000;

  showThinkingFinal(
    player,
    totalElapsed,
    forced.evaluation,
    forced.winRate,
    forced.simulations,
    'mcts'
  );
} else {
  mctsEngine.resetTo(captureCorePosition());
}

runtime.applying = true;

const appliedAction =
  applyBestAvailableAIAction(
    currentPosition,
    forced.action
  );

runtime.applying = false;

if (appliedAction !== null) {
  const totalElapsed =
    (performance.now() - searchStart) / 1000;

  const usedFallback =
    appliedAction !== forced.action;

  showThinkingFinal(
    player,
    totalElapsed,
    usedFallback
      ? 0
      : forced.evaluation,
    usedFallback
      ? 50
      : forced.winRate,
    forced.simulations,
    'mcts'
  );
} else {
  /*
   * 不再讓 finally 重新開始完整搜尋。
   */
  mctsEngine.resetTo(
    captureCorePosition()
  );

  controls[player].mode =
    AI_MODE_HUMAN;

  hideThinkingImmediately();
  renderAISettings();
}