pgnmove.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: pgnmove.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
//-----------------------------------------------------------------------
 
/** create PGN move based on basicmove_t
 *  for this, we create all moves in position and compare it
 */
bPgnMove::bPgnMove(bBoard& b, basicmove_t const bm)
  : m_move{""}
  , m_evalstr{""}
{
  bMoveList ml(b);
  movenum_t n_moves = ml.getNumberOfMoves();
  for (movenum_t moveid = 1; moveid <= n_moves; moveid++) {
    if (ml.getMoveT(moveid) == bm) {
      ctor(b, bMove(ml[moveid]));
      break;
    }
  }
}
 
bPgnMove::bPgnMove(bPgnMove const& m)
  : m_move{m.m_move}
  , m_evalstr{m.m_evalstr}
{
}
 
bPgnMove::bPgnMove(bBoard& b, bMove const& m)
  : m_move{""}
  , m_evalstr{""}
{
  ctor(b, m);
}
 
void bPgnMove::ctor(bBoard& b, bMove const& m)
{
  std::string piece = bPiece::getPieceStrUpper(b.getPiece(m.from()));
  movelist_t alternatives;
 
  if (piece == S_P_KING) {
    if (m.isCastleMove()) {
      m_move = "O-O";
      if (m.isLongCastleMove()) {
        m_move += "-O";
      }
    } else {
      m_move = piece;
    }
  } else if (piece != S_P_PAWN) {
    m_move = piece;
 
    // TOCHECK: why can't we capture alternatives, b ?
    auto getSiblings = [m](bBoard& bs) -> movelist_t {
      movelist_t siblings;
      bMoveList& ml = bs.getMoveListRef();
      movenum_t n_moves = ml.generateMoves(bs);
      for (movenum_t moveid = 1; moveid <= n_moves; moveid++) {
        bMove bm(ml[moveid]);
        if (bm.to() == m.to()) {
          if (!(bm.from() == m.from())
                  && (bs.getPiece(bm.from()) == bs.getPiece(m.from()))) {
            // same destination sq, same major piece, not same move
            siblings.emplace_back(bm);
          }
        }
      }
      return siblings;
    };
    alternatives = getSiblings(b);
  }
 
  if (m.isCapture()) {
    if (piece == S_P_PAWN) {
      m_move = (bCase(m.from()).operator std::string()).substr(0,1);
    }
    m_move += "x";
  }
 
  if (!m.isCastleMove()) {
    m_move += bCase(m.to()).operator std::string();
  }
 
  if (m.isPromotion()) {
    m_move += getPromotionDecorationStr(m.getPromotion());
  }
 
  if (alternatives.size() > 0) {
    // add column or row or both if multiple moves are possible
    // with same destination
    if (std::none_of(alternatives.begin(), alternatives.end(),
            [m](bMove const& bm)
            { return bm.fromcolumn() == m.fromcolumn(); })) {
      // add column descriptor
      m_move.insert(1, (bCase(m.from()).operator std::string()).substr(0, 1));
    } else if (std::none_of(alternatives.begin(), alternatives.end(),
            [m](bMove const& bm)
            { return bm.fromrank() == m.fromrank(); })) {
      // add row descriptor
      m_move.insert(1, (bCase(m.from()).operator std::string()).substr(1, 1));
    } else {
      // add from case, both row and column are not unique
      m_move.insert(1, (bCase(m.from()).operator std::string()));
    }
  }
 
  if (m.isCheck()) {
    if (((m.getScore() & SCORE_POSITIVE) != SCORE_THEORETIC_DRAW)
            && m.isEndOfGame()) {
      m_move += "#";
    } else {
      m_move += "+";
    }
  }
 
  if (!m_move.size()) throw std::logic_error("empty bPgnMove");
  m_evalstr = m.getMoveEvalStr();
}
 
bPgnMove::~bPgnMove()
{
  m_move.clear();
  m_evalstr.clear();
}
 
//-----------------------------------------------------------------------
 
std::string const bPgnMove::getPromotionDecorationStr(ppiece_t const piece)
        const
{
  if (piece == tPPiece::N_P_QUEEN) {
    return "=Q";
  } else if (piece == tPPiece::N_P_KNIGHT) {
    return "=N";
  } else if (piece == tPPiece::N_P_ROOK) {
    return "=R";
  } else if (piece == tPPiece::N_P_BISHOP) {
    return "=B";
  }
  throw std::logic_error("superfluous call to bPgnMove::getPromotionDecorationStr");
}
 
//-----------------------------------------------------------------------
 
bool operator==(bPgnMove const& lhs, std::string const& rhs)
{
  if (lhs.m_move == rhs) return true;
  return false;
}
 
std::ostream& operator<<(std::ostream& os, bPgnMove const& m)
{
  os << m.m_move;
  return os;
}
 
//-----------------------------------------------------------------------
 
bPgnMoveList::bPgnMoveList()
  : m_pmoves{}
{
}
 
bPgnMoveList::bPgnMoveList(bBoard& b)
  : m_pmoves{}
{
  bMoveList& ml = b.getMoveListRef();
  movenum_t n_moves = ml.generateMoves(b);
  for (movenum_t moveid = 1; moveid <= n_moves; moveid++) {
    m_pmoves.emplace_back(b, ml[moveid]);
  }
}
 
bPgnMoveList::~bPgnMoveList()
{
  m_pmoves.clear();
}
 
std::ostream& operator<<(std::ostream& os, bPgnMoveList const& mpl)
{
  os << "#" << belofte::to_string(static_cast<int64_t>(mpl.m_pmoves.size())) << " ";
  for (bPgnMove const& m: mpl.m_pmoves) {
    os << m << m.getMoveEvalStr() << " ";
  }
  return os;
}
 
// eof