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 bMove
 */
bPgnMove::bPgnMove(bBoard const& b, bmove_t const bmt)
  : m_move{}
  , m_evalstr{}
{
  bMoveList ml;
  ml.generateMoves(b);
  movenum_t n_moves = ml.getNumberOfMoves();
  for (movenum_t moveid = 1; moveid <= n_moves; ++moveid) {
    bMove m = ml[moveid];
    if (m == bmt) {
      ctor(b, m);
      break;
    }
  }
}
 
void bPgnMove::ctor(bBoard const& 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;
 
    /// @todo check why can't we capture alternatives, b ?
    auto getSiblings = [m](bBoard const& bs) -> movelist_t {
      movelist_t siblings;
      bMoveList ml;
      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.push_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.isDrawScore()) && m.isMateMove()) {
      m_move += "#";
    } else {
      m_move += "+";
    }
  }
 
  if (!m_move.size()) throw std::logic_error("empty bPgnMove");
  m_evalstr = m.getMoveEvalStr();
}
 
//-----------------------------------------------------------------------
 
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");
}
 
//-----------------------------------------------------------------------
 
bPgnMoveList::bPgnMoveList(bBoard const& b)
  : m_pmoves{}
{
  bMoveList ml;
  movenum_t n_moves = ml.generateMoves(b);
  for (movenum_t moveid = 1; moveid <= n_moves; ++moveid) {
    bPgnMove pm(b, ml[moveid].getBMoveT());
    m_pmoves.push_back(pm);
  }
}
 
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