move.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: move.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
//-----------------------------------------------------------------------
// bBasicMove functions
 
bBasicMove::bBasicMove(bBasicMove const& bm)
  : u_bmove{bm.u_bmove}
{
}
 
bBasicMove::bBasicMove(bBasicMove&& bm)
  : u_bmove{std::move(bm.u_bmove)}
{
}
 
bBasicMove::bBasicMove(basicmove_t const bmt)
  : m_bmove{bmt}
{
  // TODO: add initial sorting score
}
 
bBasicMove::bBasicMove(case_t cf, case_t ct)
{
  // TODO: add initial sorting score
  m_bmove = static_cast<basicmove_t>((ct << 8) | cf);
}
 
bBasicMove::~bBasicMove()
{
}
 
bBasicMove& bBasicMove::operator=(bBasicMove const& bm)
{
  u_bmove = bm.u_bmove;
  return *this;
}
 
bBasicMove& bBasicMove::operator=(bBasicMove&& bm)
{
  u_bmove = std::move(bm.u_bmove);
  return *this;
}
 
bBasicMove::operator std::string() const
{
  return bCase(from()).operator std::string()
          + bCase(to()).operator std::string()
          + getPromotionDecorationStr();
}
 
std::string const bBasicMove::getPromotionDecorationStr() const
{
  if (!m_promotion) {
    return "";
  } else if (m_promotion == tPPiece::N_P_QUEEN) {
    return "q";
  } else if (m_promotion == tPPiece::N_P_KNIGHT) {
    return "n";
  } else if (m_promotion == tPPiece::N_P_ROOK) {
    return "r";
  } else {
    return "b";
  }
}
 
std::ostream& operator<<(std::ostream& os, bBasicMove const& m)
{
  os << m.operator std::string();
  return os;
}
 
//-----------------------------------------------------------------------
// bMove functions
 
bMove::bMove(bMove const& m)
  : bBasicMove{m}
  , m_score{m.m_score}
{
}
 
bMove::bMove(bMove&& m)
  : bBasicMove{std::move(m)}
  , m_score{std::move(m.m_score)}
{
}
 
bMove::bMove(case_t cf, case_t ct)
  : bBasicMove{cf, ct}
{
}
 
bMove::~bMove()
{
}
 
bMove& bMove::operator=(bMove&& m)
{
  bBasicMove::operator=(std::move(m));
  m_score = std::move(m.m_score);
  return *this;
}
 
bool bMove::operator>(bMove const& r) const
{
  return belofte::realScore(m_score) > belofte::realScore(r.m_score);
}
 
// TODO: convert to move annotation to be used in PgnMove as well
std::string bMove::getMoveEvalStr() const
{
  std::string str;
  if (isCheck()) {
    if (((m_score & SCORE_POSITIVE) != SCORE_THEORETIC_DRAW)
            && isEndOfGame())
      str = "#";
    else
      str = "+";
  }
  if (isEPMove()) str += (str != "") ? " e.p." : "e.p.";
  else if (isCapture()) str += (str != "") ? " x" : "x";
  if ((m_score & SCORE_POSITIVE) != SCORE_PUNDEFINED) {
    if (str != "") str += " ";
    str += belofte::scoreAsStr(m_score);
  }
  if (str != "") return " {" + str + "}";
  return "";
}
 
/**
 * Flag if mated
 * @return true if game ended
 */
bool bMove::isEndOfGame() const
{
  if (getGameEnd()) return true;
  if (((m_score & SCORE_POSITIVE) != SCORE_PUNDEFINED) && isCheck()) {
    if ((m_score & SCORE_POSITIVE) >= (SCORE_MATE - SCORE_CONVERGE_BYDEPTH)) return true;
  }
  return false;
}
 
/** test if major promotion or mating promotion (queen, knight)
 * if minor promotion, move is considered as silent
 */
bool bMove::isMajorPromotion() const
{
  if ((m_promotion == tPPiece::N_P_QUEEN)
      || (m_promotion == tPPiece::N_P_KNIGHT)) return true;
  return false;
}
 
piece_t bMove::getWhitePromotionPiece() const
{
  if (m_promotion == tPPiece::N_P_QUEEN) {
    return tPiece::W_QUEEN;
  } else if (m_promotion == tPPiece::N_P_KNIGHT) {
    return tPiece::W_KNIGHT;
  } else if (m_promotion == tPPiece::N_P_ROOK) {
    return tPiece::W_ROOK;
  } else if (m_promotion == tPPiece::N_P_BISHOP) {
    return tPiece::W_BISHOP;
  }
  throw std::logic_error("getWhitePromotionPiece called with tPiece::FIELD_EMPTY");
}
 
piece_t bMove::getBlackPromotionPiece() const
{
  if (m_promotion == tPPiece::N_P_QUEEN) {
    return tPiece::B_QUEEN;
  } else if (m_promotion == tPPiece::N_P_KNIGHT) {
    return tPiece::B_KNIGHT;
  } else if (m_promotion == tPPiece::N_P_ROOK) {
    return tPiece::B_ROOK;
  } else if (m_promotion == tPPiece::N_P_BISHOP) {
    return tPiece::B_BISHOP;
  }
  throw std::logic_error("getBlackPromotionPiece called with tPiece::FIELD_EMPTY");
}
 
// eof