search_abfh.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: search_abfh.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
//-----------------------------------------------------------------------
 
/**
 * Intermediate overwriting procedure for algorithm
 * @param b board
 * @param ml movelist of this position
 * @param nDepth depth to search on
 * @param alpha value
 * @param beta beta
 * @todo check why not test for winning before evaluating moves
 */
bScore SearchAlphaBetaFH::CalcBestMove(bBoard& b,
        bMoveList& ml, depth_t const nDepth,
        bSearchScore alpha, bSearchScore beta)
{
  if (getLevel()->searchDepthReached(nDepth)) {
    return Quiescence(b, nDepth, alpha, beta, (b.isInCheck() ? 1 : 0));
  }
 
  movenum_t n_moves = ml.generateMoves(b);
 
  bScore terminalScore = RetrieveBoardEvaluation(b);
 
  DEBUG_sendInfoSearchingNS(b, nDepth, alpha
          + " " + beta
          + " static: " + engineInterface::scoreAsString(terminalScore)
          + (b.isInCheck() ? " check" : ""));
 
  if (bSearchScore::isDrawScore(terminalScore)) {
    ++m_leafnodes;
    DEBUG_sendInfoSearchingNS(b, nDepth, "(th. draw)");
    return SCORE_THEORETIC_DRAW;
  }
 
  if (!n_moves) {
    ++m_leafnodes;
    DEBUG_sendInfoSearching(b, nDepth, "(dead position)", terminalScore);
    return terminalScore;
  }
 
  adjustMaxSearchedDepth(nDepth);
  if (nDepth > 2 && nDepth % 2) CheckIfAbortingSearch();
 
  depth_t nNewDepth = nDepth + 1;
  bSearchScore bestscore(-SCORE_INFINITE);
  ml.sortMoves();
  for (movenum_t moveid = 1; moveid <= n_moves; ++moveid) {
    bMove m(ml[moveid]);
    sendInfoCurrMove(b, nDepth, m, moveid);
    bBoard chldbrd(b, m);
    chldbrd.applyMove(m);
    chldbrd.calcMinorPieces();
    bMoveList chldML;
    bSearchScore chldscore(-CalcBestMove(chldbrd, chldML, nNewDepth, -beta, -alpha));
    chldscore.convergeScore(chldscore.getScore());
    ml.setScoreOfMove(moveid, chldscore.getScore());
    if (chldscore.isWinning()) {
      b.setVariation(chldbrd);
      ++m_nonleafnodes;
      DEBUG_sendInfoSearching(b, nDepth, "(winning)", chldscore.getScore());
      return chldscore.getScore();
    }
    if (chldscore.improvesOn(m_nBetaCutOffMargin, beta)) {
      ++m_nonleafnodes;
      DEBUG_sendInfoSearchingNS(b, nDepth, "(fail hard) " + chldscore + GTOREQUAL + beta);
      return beta.getScore();
    }
    if (chldscore.improvesOn(alpha)) {
      b.setVariation(chldbrd);
      DEBUG_sendInfoSearchingNS(b, nDepth, "alpha & best update " + chldscore + " > " + alpha);
      bestscore = chldscore.getScore();
      alpha = chldscore.getScore(); // alpha does not change type
    } else {
      DEBUG_sendInfoSearchingNS(b, nDepth, "no update " + chldscore);
    }
  }
 
  ++m_nonleafnodes;
  DEBUG_sendInfoSearching(b, nDepth, "(return best)", bestscore.getScore());
  return bestscore.getScore();
}
 
//-----------------------------------------------------------------------
 
// eof