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"
 
//-----------------------------------------------------------------------
 
SearchBruteForce::SearchBruteForce()
  : bSearchAlgorithm("BruteForce")
{
}
 
SearchBruteForce::SearchBruteForce(std::string const& n)
  : bSearchAlgorithm(n)
{
}
 
SearchBruteForce::~SearchBruteForce()
{
}
 
bBestMoveInfo SearchBruteForce::CalcBestMove(bBoard& b)
{
  // TODO: search from depth till zero
  bBestMoveInfo result;
  result = CalcBestMove(b, 0);
  return result;
}
 
/**
 * Actual search, recursively callable
 * @param b board
 * @param nDepth remaining depth to search on
 * @return SCORE_UNDEFINED | [-]SCORE_INFINITE | actual score
 */
bScore SearchBruteForce::CalcBestMove(bBoard& b, depth_t const& nDepth)
{
  if (nDepth > m_maxDepth) m_maxDepth = nDepth;
  std::string izing = std::string(b.minimizing() > 0 ? "White" : "Black") + " to move";
  movenum_t n_moves = b.generateAtLeastOneMove();
 
  bScore sc = RetrieveBoardEvaluation(b);
  if (getLevel()->depthReached(nDepth)) {
    ++m_leafnodes;
    return sendInfoSearching(b, nDepth, izing + " - Depth reached", sc);
  }
  if (nDepth) ++m_nonleafnodes;
 
  bSearchScore bestscore(-SCORE_INFINITE, tScoreType::SC_BEST);
 
  if (!n_moves) {
    return sendInfoSearching(b, nDepth, izing + " - Dead position", sc);
  } else {
    sendInfoSearching(b, nDepth, izing + " - (static eval)", sc);
    n_moves = b.generateMoves();
    bMoveList& ml = b.getMoves();
    for (movenum_t moveid = 1; moveid <= n_moves; moveid++) {
      handleInfoCurrMove(b, ml, nDepth, moveid);
      bBoard chldbrd(b, ml[moveid], ml.getMoveT(moveid));
      bSearchScore chldscore(CalcBestMove(chldbrd, nDepth + 1), tScoreType::SC_CHILD);
      chldscore = -attenuateScore(chldscore.getScore());
      ml.updateScoreOfBestMove(moveid, chldscore.getScore());
      if (chldscore > bestscore) {
        b.setVariation(chldbrd);
        bestscore = chldscore.getScore();
      }
    }
  }
 
  return sendInfoSearching(b, nDepth, "(return best)", bestscore.getScore());
}
 
//-----------------------------------------------------------------------
 
SearchIterativeBF::SearchIterativeBF()
  : SearchBruteForce("SearchIterativeBF")
{
  m_iterativesearch = true;
}
 
SearchIterativeBF::~SearchIterativeBF()
{
}
 
// eof