movelist.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: movelist.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
bMoveList::bMoveList()
  : m_lmoves{}
{
}
 
bMoveList::bMoveList(bBoard const& b)
  : m_lmoves{}
{
  generateMoves(b);
}
 
bMoveList::~bMoveList()
{
  m_lmoves.clear();
}
 
//-----------------------------------------------------------------------
 
void bMoveList::addMoveAndSetScore(bBoard const& b, bMove const& m,
        bool const check)
{
  bScore sc = 0;
  bMove nm(m);
  if (check) {
    nm.setCheck();
    bBoard nb(b, const_cast<bMove const&>(nm));
    if (!nb.atLeastOneMovePossible())
      nm.setGameEnd();
  }
 
  if (nm.getGameEnd()) {
    sc = SCORE_MATE;
  } else {
    // malus points for moving own piece, except for pawn
    sc += bPositionEvaluation::mymove_pieceValue(b.getPiece(nm.from()));
    if (nm.isCapture()) {
      sc += bPositionEvaluation::pieceValue(b.getPiece(nm.to()));
    }
    sc -= bPositionEvaluation::centerplay_pieceValue(nm.from());
    sc += bPositionEvaluation::centerplay_pieceValue(nm.to());
    if (nm.isPromotion()) {
      sc += 300;
      if (nm.isMajorPromotion()) sc += 500;
    }
    if (nm.isPawnMove() && (b.getStage() == bGameStage::ST_PAWNENDING)) sc += 10;
    if (nm.isCheck()) sc += 80; // check is less than a pawn, we prefer captures
    if (nm.isCastleMove()) sc += 250; // malus for king move 200, so half a pawn
  }
  if (nm.isNonSilent()) m_nQSMoves++;
#if !defined(INCOMPLETE_C11)
  if (m_bestmoveid && (sc >= m_lmoves[m_bestmoveid - 1].getScore())) {
    // this move is better or equal than all previous moves, so insert it at front
    m_lmoves.insert(m_lmoves.begin(), nm);
    setScoreOfMove(1, sc);
  } else {
#endif
    m_lmoves.emplace_back(nm);
    setScoreOfMove(static_cast<movenum_t>(m_lmoves.size()), sc);
#if !defined(INCOMPLETE_C11)
  }
#endif
}
 
/**
 * Only add move to movelist if valid
 * @param b board on which move is calculated
 * @param m move to be added
 * @return number of moves added (1), meaning player is not in check after move
 */
movenum_t bMoveList::addWhiteMoveIfValid(bBoard const& b, bMove const& m)
{
  bBoard newboard(b, m);
  bWhiteKing const* wking = static_cast<bWhiteKing *>(bPiece::getPieceClass(tPiece::W_KING));
  if (wking->isAttacked(newboard, newboard.getWhiteKingPos())) return 0;
  bBlackKing const* bking = static_cast<bBlackKing *>(bPiece::getPieceClass(tPiece::B_KING));
  addMoveAndSetScore(b, m, bking->isAttacked(newboard, newboard.getBlackKingPos()));
  return 1;
}
 
movenum_t bMoveList::addWhiteCaptureIfValid(bBoard const& b, case_t const& cf, case_t const& to)
{
  bMove m(cf, to);
  m.setCapture();
  return addWhiteMoveIfValid(b, m);
}
 
/**
 * Only add move to movelist if valid
 * @param b board on which move is calculated
 * @param m move to be added
 * @return number of moves added (1), meaning player is not in check after move
 */
movenum_t bMoveList::addBlackMoveIfValid(bBoard const& b, bMove const& m)
{
  bBoard newboard(b, m);
  bBlackKing const* bking = static_cast<bBlackKing *>(bPiece::getPieceClass(tPiece::B_KING));
  if (bking->isAttacked(newboard, newboard.getBlackKingPos())) return 0;
  bWhiteKing const* wking = static_cast<bWhiteKing *>(bPiece::getPieceClass(tPiece::W_KING));
  addMoveAndSetScore(b, m, wking->isAttacked(newboard, newboard.getWhiteKingPos()));
  return 1;
}
 
movenum_t bMoveList::addBlackCaptureIfValid(bBoard const& b, case_t const& cf, case_t const& to)
{
  bMove m(cf, to);
  m.setCapture();
  return addBlackMoveIfValid(b, m);
}
 
/**
 * Only add move to movelist if valid
 * @param b board on which move is calculated
 * @param m move to be added
 * @return number of moves added (4), meaning, player is not in check after move
 */
movenum_t bMoveList::addWhitePromotionIfValid(bBoard const& b, bMove const& m)
{
  bBoard newboard(b, m);
  bWhiteKing const* wking = static_cast<bWhiteKing *>(bPiece::getPieceClass(tPiece::W_KING));
  if (wking->isAttacked(newboard, newboard.getWhiteKingPos())) return 0;
 
  bBlackKing const* bking = static_cast<bBlackKing *>(bPiece::getPieceClass(tPiece::B_KING));
 
  // we are promoting, but did apply a dummy move on top
  // so modify dest board with custom pieces and check for in check
  bMove newmove(m);
  case_t to = m.to();
  case_t bKingPos = newboard.getBlackKingPos();
 
  // TODO: optimize in case of uncover check just by moving pawn
  newboard.setPiece(to, tPiece::W_QUEEN);
  bool oppInCheckByQueen = bking->isAttacked(newboard, bKingPos);
  newmove.setPromotion(tPPiece::N_P_QUEEN);  addMoveAndSetScore(b, newmove, oppInCheckByQueen);
 
  newboard.setPiece(to, tPiece::W_KNIGHT);
  bool oppInCheck = bking->isAttacked(newboard, bKingPos);
  newmove.setPromotion(tPPiece::N_P_KNIGHT); addMoveAndSetScore(b, newmove, oppInCheck);
 
  newboard.setPiece(to, tPiece::W_ROOK);
  // do not re-evaluate check by rook if queen did not give check
  oppInCheck = oppInCheckByQueen && bking->isAttacked(newboard, bKingPos);
  newmove.setPromotion(tPPiece::N_P_ROOK);   addMoveAndSetScore(b, newmove, oppInCheck);
 
  newboard.setPiece(to, tPiece::W_BISHOP);
  oppInCheck = oppInCheckByQueen && bking->isAttacked(newboard, bKingPos);
  newmove.setPromotion(tPPiece::N_P_BISHOP); addMoveAndSetScore(b, newmove, oppInCheck);
  return 4;
}
 
/**
 * Only add move to movelist if valid
 * @param b board on which move is calculated
 * @param m move to be added
 * @return number of moves added (4), meaning, player is not in check after move
 */
movenum_t bMoveList::addBlackPromotionIfValid(bBoard const& b, bMove const& m)
{
  bBoard newboard(b, m);
  bBlackKing const* bking = static_cast<bBlackKing *>(bPiece::getPieceClass(tPiece::B_KING));
  if (bking->isAttacked(newboard, newboard.getBlackKingPos())) return 0;
 
  bWhiteKing const* wking = static_cast<bWhiteKing *>(bPiece::getPieceClass(tPiece::W_KING));
 
  // we are promoting, but did apply a dummy move on top
  // so modify dest board with custom pieces and check for in check
  bMove newmove(m);
  case_t to = m.to();
  case_t wKingPos = newboard.getWhiteKingPos();
 
  // TODO: optimize in case of uncover check just by moving pawn
  newboard.setPiece(to, tPiece::B_QUEEN);
  bool oppInCheckByQueen = wking->isAttacked(newboard, wKingPos);
  newmove.setPromotion(tPPiece::N_P_QUEEN);  addMoveAndSetScore(b, newmove, oppInCheckByQueen);
 
  newboard.setPiece(to, tPiece::B_KNIGHT);
  bool oppInCheck = wking->isAttacked(newboard, wKingPos);
  newmove.setPromotion(tPPiece::N_P_KNIGHT); addMoveAndSetScore(b, newmove, oppInCheck);
 
  newboard.setPiece(to, tPiece::B_ROOK);
  // do not re-evaluate check by rook if queen did not give check
  oppInCheck = oppInCheckByQueen && wking->isAttacked(newboard, wKingPos);
  newmove.setPromotion(tPPiece::N_P_ROOK);   addMoveAndSetScore(b, newmove, oppInCheck);
 
  newboard.setPiece(to, tPiece::B_BISHOP);
  oppInCheck = oppInCheckByQueen && wking->isAttacked(newboard, wKingPos);
  newmove.setPromotion(tPPiece::N_P_BISHOP); addMoveAndSetScore(b, newmove, oppInCheck);
  return 4;
}
 
//-----------------------------------------------------------------------
 
/**
 * Store score of move
 * @param moveid of move to be stored [1 -> max number of moves]
 * @param score to be stored
 * @return moveid of new best move if updated, or zero if no update
 */
movenum_t bMoveList::setScoreOfMove(movenum_t const moveid, bScore const score)
{
  if (m_bestmoveid) {
    if (score > m_lmoves[m_bestmoveid - 1].getScore()) {
      // improvement
      m_bestmoveid = moveid;
      m_isSorted = false;
    }
  } else {
    // no bestmove id stored yet
    m_bestmoveid = moveid;
    m_isSorted = false;
  }
  m_lmoves[moveid - 1].setScore(score);
 
  return m_bestmoveid;
}
 
movenum_t bMoveList::sortMoves()
{
  size_t nS = m_lmoves.size();
  if (nS) {
    if (!m_isSorted) {
      if (nS >= 5) {
        if (m_nQSMoves) {
          // only interested in 2 best scores in case of QS moves
          std::partial_sort(m_lmoves.begin(), m_lmoves.begin() + 2, m_lmoves.end(),
            [](bMove const& a, bMove const& b) { return a > b; });
        } else {
          // only interested in 4 best scores
          std::partial_sort(m_lmoves.begin(), m_lmoves.begin() + 4, m_lmoves.end(),
            [](bMove const& a, bMove const& b) { return a > b; });
        }
      } else {
        // sort all in case of 1 to 4 elements
        std::sort(m_lmoves.begin(), m_lmoves.end(),
          [](bMove const& a, bMove const& b) { return a > b; });
      }
      m_isSorted = true;
      m_bestmoveid = 1;
    }
  } else {
    m_bestmoveid = 0;
  }
  return m_bestmoveid;
}
 
//-----------------------------------------------------------------------
 
/**
 * generate moves if not yet generated
 */
movenum_t bMoveList::generateMoves(bBoard const& b)
{
  if (!m_isGenerated) {
    m_isGenerated = true;
    side_t sidetomove = b.getColourToMove();
    if (sidetomove == tSide::SIDE_WHITE) {
      for (case_t iCase = 0; iCase < 64; ++iCase) {
        piece_t p = b.getPiece(iCase);
        if (bPiece::isWhitePiece(p)) {
          (bPiece::getPieceClass(p))->GenerateMoves(b, iCase, *this);
        }
      }
    } else {
      for (case_t iCase = 64; iCase > 0;) {
        --iCase;
        piece_t p = b.getPiece(iCase);
        if (bPiece::isBlackPiece(p)) {
          (bPiece::getPieceClass(p))->GenerateMoves(b, iCase, *this);
        }
      }
    }
  }
  return static_cast<movenum_t>(m_lmoves.size());
}
 
void bMoveList::emptyMoveList()
{
  m_lmoves.clear();
  m_isGenerated = false;
  m_isSorted = false;
  m_nQSMoves = 0;
  m_bestmoveid = 0;
}
 
/**
 * see if at least one move can be played e.g. (stale-)mate eval
 */
bool bMoveList::atLeastOneMovePossible(bBoard const& b) const
{
  if (m_isGenerated) return (m_lmoves.size() > 0);
 
  bBoard nb(b);
  if (b.getColourToMove() == tSide::SIDE_WHITE) {
    for (case_t iCase = 0; iCase < 64; ++iCase) {
      piece_t p = nb.getPiece(iCase);
      if (bPiece::isWhitePiece(p)) {
        if (bPiece::getPieceClass(p)->hasValidMovePreflightCheck(nb, iCase))
          return true;
      }
    }
  } else {
    for (case_t iCase = 64; iCase > 0;) {
      --iCase;
      piece_t p = nb.getPiece(iCase);
      if (bPiece::isBlackPiece(p)) {
        if (bPiece::getPieceClass(p)->hasValidMovePreflightCheck(nb, iCase))
          return true;
      }
    }
  }
  return false;
}
 
bMove const& bMoveList::operator[](movenum_t const moveid) const
{
  return m_lmoves[moveid - 1];
}
 
basicmove_t bMoveList::getMoveT(movenum_t const moveid) const
{
  return m_lmoves[moveid - 1].getBasicMoveT();
}
 
movenum_t bMoveList::getNumberOfMoves() const
{
  return static_cast<movenum_t>(m_lmoves.size());
}
 
/** return number of non silent moves
*/
movenum_t bMoveList::getNumberOfQSMoves() const
{
  return m_nQSMoves;
}
 
//-----------------------------------------------------------------------
 
std::ostream& operator<<(std::ostream& os, bMoveList const& ml)
{
  os << "#" << static_cast<int>(ml.getNumberOfMoves()) << " ";
  for (bMove const& m: ml.m_lmoves) {
    os << m << m.getMoveEvalStr() << " ";
  }
  return os;
}
 
// eof