search_bf.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: search_bf.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
//-----------------------------------------------------------------------
 
/**
 * Root search for BF, depth 0
 * @param b board
 * @param ml movelist of this position
 * @todo search from depth till zero
 */
bScore SearchBruteForce::CalcBestMove(bBoard& b, bMoveList& ml)
{
  bBoard searchBoard(b);
  depth_t const nDepth = 0;
  bScore score = CalcBestMove(searchBoard, ml, nDepth);
#if defined(_DEBUG)
  ml.setNeedSorted();
  ml.sortMoves(false);
#endif
  return score;
}
 
/**
 * Search from depth 0 on
 * @param b board
 * @param ml movelist of this position
 * @param nDepth remaining depth to search on
 * @return [-]SCORE_UNDEFINED | [-]SCORE_INFINITE | actual score
 */
bScore SearchBruteForce::CalcBestMove(bBoard& b, bMoveList& ml, depth_t const nDepth)
{
  gameResult_t gr = bPositionEvaluation::gameEndedResult(b);
  if (isNoBench() && gr != GR_UNKNOWN) {
    ++m_leafnodes; // leaf node because of final position
    if (bPositionEvaluation::isDrawResult(gr)) {
      DEBUG_sendInfoSearchingNS(b, nDepth, "(draw)");
      return SCORE_THEORETIC_DRAW;
    }
    bScore terminalScore = bPositionEvaluation::resultToScoreFlag(gr) * b.minimizing();
    DEBUG_sendInfoSearching(b, nDepth, "(final score)", terminalScore);
    return terminalScore;
  }
 
  adjustMaxSearchedDepth(nDepth);
 
  if (getLevel()->searchDepthReached(nDepth)) {
    ++m_leafnodes;
    bScore terminalScore = RetrieveBoardEvaluation(b, gr, true);
    DEBUG_sendInfoSearching(b, nDepth, "Depth reached", terminalScore);
    return terminalScore;
  }
 
  if (nDepth) ++m_nonleafnodes;
  if (nDepth > 2 && nDepth % 2) CheckIfAbortingSearch();
 
  ml.clearNeedSorted();
  ml.clearKeepScores();
  movenum_t n_moves = ml.generateMoves(b);
 
  if (!n_moves && isBench()) {
    bScore terminalScore = RetrieveBoardEvaluation(b, gr, true);
    DEBUG_sendInfoSearching(b, nDepth, "Dead position", terminalScore);
    return terminalScore;
  }
 
  depth_t nNewDepth = nDepth + 1;
  ml.clearScores();
  ml.setKeepScores();
  for (ml.curmoveid = 1; ml.curmoveid <= n_moves; ++ml.curmoveid) {
    bMove m(ml[ml.curmoveid]);
    sendInfoCurrMove(b, nDepth, m, ml.curmoveid);
    bMoveList chldML;
    boardInfo_t bi = b.bBasicBoard::applyMove(m);
    bScore chldscore = -CalcBestMove(b, chldML, nNewDepth);
    b.bBasicBoard::unApplyMove(m, bi);
    ml.setScoreOfMoveUnsorted(ml.curmoveid, chldscore);
  }
 
  bScore bestScore = bSearchScore::convergeScore(ml.getBestMoveScore());
  ml.setBestMoveScore(bestScore);
  DEBUG_sendInfoSearching(b, nDepth, "(return best)", bestScore);
  return bestScore;
}
 
// eof