eval.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 * File: eval.cpp
 * Project: part of belofte - A Promising Chess Program
 * Author: yves
 * SPDX-License-Identifier: GPL-2.0-only
+----------------------------------------------------------------------*/
 
#include "belofte.h"
 
static uint8_t whitefields[64] = { // 1 = white, 2 = black
  1, 2, 1, 2, 1, 2, 1, 2,
  2, 1, 2, 1, 2, 1, 2, 1,
  1, 2, 1, 2, 1, 2, 1, 2,
  2, 1, 2, 1, 2, 1, 2, 1,
  1, 2, 1, 2, 1, 2, 1, 2,
  2, 1, 2, 1, 2, 1, 2, 1,
  1, 2, 1, 2, 1, 2, 1, 2,
  2, 1, 2, 1, 2, 1, 2, 1
};
 
//-----------------------------------------------------------------------
 
bScore belofte::realScore(bScore const sc)
{
  if ((sc & SCORE_POSITIVE) == SCORE_PUNDEFINED) return SCORE_UNDEFINED;
  if ((sc & SCORE_POSITIVE) == SCORE_THEORETIC_DRAW) return SCORE_DRAW;
  return sc;
}
 
//-----------------------------------------------------------------------
 
/**
 * See if board is in finite state, meaning game is ended
 * @param b board is a reference, if no moves have been generated, a
 * copy is created, moves are generated and a recursive call is done
 * @return mate, stalemate, draw or further evaluation required
 */
gameResult_t bPositionEvaluation::isGameEnded(bBoard const& b) const
{
  if (!b.atLeastOneMovePossible()) {
    if (b.whiteToMove()) {
      bWhiteKing const* king = static_cast<bWhiteKing *>(bPiece::getPieceClass(tPiece::W_KING));
      if (king->isAttacked(b, b.getWhiteKingPos())) {
        return GR_BLACKMATES;
      }
      return GR_DRAW_STALEMATE;
    } else {
      bBlackKing const* king = static_cast<bBlackKing *>(bPiece::getPieceClass(tPiece::B_KING));
      if (king->isAttacked(b, b.getBlackKingPos())) {
        return GR_WHITEMATES;
      }
      return GR_DRAW_STALEMATE;
    }
  }
  if (b.getPly50Moves() >= 100) return GR_DRAW_50;
  if (insufficientMaterial(b)) return GR_DRAW_LACKMATERIAL;
  if (threeFoldRepetition(b)) return GR_DRAW_THREEFOLD;
 
  return GR_UNKNOWN;
}
 
/** convert all draw scores to SCORE_THEORETIC_DRAW
 */
bScore bPositionEvaluation::resultToScoreFlag(gameResult_t const sc) const
{
  if (sc == GR_BLACKMATES) return -SCORE_MATE;
  else if (sc == GR_WHITEMATES) return SCORE_MATE;
  return SCORE_THEORETIC_DRAW;
}
 
/**
 * Get piecelist in normalized form (all uppercase)
 * @param b board
 * @return piecelist in form K+whitepieces+K+blackpieces in uppercase
 */
std::string bPositionEvaluation::getPieceList(bBoard const& b)
        const
{
  return "K" + std::string((b.m_whitePieces[tStatPiece::STAT_ROOK]).size(), 'R')
          + std::string((b.m_whitePieces[tStatPiece::STAT_KNIGHT]).size(), 'N')
          + std::string((b.m_whitePieces[tStatPiece::STAT_BISHOP]).size(), 'B')
          + std::string((b.m_whitePieces[tStatPiece::STAT_QUEEN]).size(), 'Q')
          + std::string((b.m_whitePieces[tStatPiece::STAT_PAWN]).size(), 'P')
          + "K" + std::string((b.m_blackPieces[tStatPiece::STAT_ROOK]).size(), 'R')
          + std::string((b.m_blackPieces[tStatPiece::STAT_KNIGHT]).size(), 'N')
          + std::string((b.m_blackPieces[tStatPiece::STAT_BISHOP]).size(), 'B')
          + std::string((b.m_blackPieces[tStatPiece::STAT_QUEEN]).size(), 'Q')
          + std::string((b.m_blackPieces[tStatPiece::STAT_PAWN]).size(), 'P');
}
 
bool bPositionEvaluation::insufficientMaterial(bBoard const& b) const
{
  if (b.m_piecesonboard > 4) return false; // >4 pieces, never theoretic draw
  std::string mat = getPieceList(b);
 
  // "KBKB" is draw only with opposite colour bishops by FIDE rule
  if (mat == "KBKB") return sameColorBishops(b);
 
  // other >3 pieces, never material draw ("KNKN", "KNKB", "KBKN" are not draws by FIDE rule)
  if (mat.size() > 3) return false;
 
  if (mat.find('P') < mat.length()) return false; // with pawn, no material draw
  if (mat.find('Q') < mat.length()) return false; // with queen, no material draw
  if (mat.find('R') < mat.length()) return false; // with rook, no material draw
  std::string const nullpositions[] = {"KK", "KNK", "KKN", "KBK", "KKB"};
  auto it = std::find(std::begin(nullpositions), std::end(nullpositions), mat);
  return it != std::end(nullpositions);
}
 
bool bPositionEvaluation::sameColorBishops(bBoard const& b) const
{
  uint8_t whitemask = 0;
  uint8_t blackmask = 0;
 
  if (b.m_whitePieces[STAT_BISHOP].size()) {
    for (unsigned int i=0; i < b.m_whitePieces[STAT_BISHOP].size(); i++) {
      whitemask |= whitefields[b.m_whitePieces[STAT_BISHOP][i]];
    }
  }
 
  if (b.m_blackPieces[STAT_BISHOP].size()) {
    for (unsigned int i=0; i < b.m_blackPieces[STAT_BISHOP].size(); i++) {
      blackmask |= whitefields[b.m_blackPieces[STAT_BISHOP][i]];
    }
  }
 
  return whitemask == blackmask;
}
 
int8_t bPositionEvaluation::nFoldRepetition(bBoard const& b) const
{
  int8_t nRepetitionCount = 1;
  int16_t nMovesSinceLastPawnMove = b.getPly50Moves();
  hashkey_t currentHash = b.getHash();
  hashkey_t nPieceCnt = currentHash & HASH_ODDMATERIAL;
 
  // TODO: we need to iterate through positions to get here,
  // and not only on gamehistory
  positions_t& positions = Game()->getPositions();
 
  std::vector<bBoard>::reverse_iterator it = positions.rbegin();
 
  // if first position is same as board, do not count it but skip
  // this in case if evaluation is called on current game stack only
  if ((it != positions.rend())) if ((*it).getHash() == currentHash) ++it;
 
  while (it != positions.rend()) {
    if ((*it).getHash() == currentHash) ++nRepetitionCount;
    // should not go any further, 3 times already
    if (nRepetitionCount > 2) break;
    // we are nMoves since last pawn/capture move, and still no repetition
    if (!(nMovesSinceLastPawnMove--)) break;
    // capture move, so no threefold repetition
    if (((*it).getHash() & HASH_ODDMATERIAL) != nPieceCnt) break;
    ++it;
  }
 
  return nRepetitionCount;
}
 
bool bPositionEvaluation::twoFoldRepetition(bBoard const& b) const
{
  if (b.getPly50Moves() < 4) return false;
  return (nFoldRepetition(b) > 1);
}
 
bool bPositionEvaluation::threeFoldRepetition(bBoard const& b) const
{
  if (b.getPly50Moves() < 6) return false;
  return (nFoldRepetition(b) > 2);
}
 
//-----------------------------------------------------------------------
 
static bScore roundedpiecevalues[tPiece::P_SIZE] = {
  // empty, king, pawn, knight, bishop, rook queen
  // black pieces have negative score
  0, 0, 100, 300, 300, 500, 900
};
 
static bScore piecevalues[tPiece::P_SIZE] = {
  // empty, king, pawn, knight, bishop, rook queen
  // black pieces have positive score as well
  0, 2000, 100, 340, 360, 525, 950
};
 
static bScore mymove_piecevalues[tPiece::P_SIZE];
 
// bottom left position is a8, then b8, topmost a1 - h1
// score for black pieces is inverted
static bScore positionvalues[tPiece::P_SIZE][64] = {
  // empty
  {},
  // White King
  {
    5, 6, 8, 0, 0, 2, 10, 5,
    0, 0, 1, -2, -3, -1, 2, 0,
    -2, -3, -5, -5, -5, -5, -2, 0,
    -6, -6, -6, -6, -6, -6, -6, -6,
    -5, -2, -5, -5, -5, -5, -2, -5,
    -5, 0, 0, 0, 0, 0, 0, -5,
    -15, -10, -10, -10, -10, -10, -10, -15,
    -20, -15, -10, -10, -10, -10, -15, -20
  },
  // White Pawn
  {
    0, 0, 0, 0, 0, 0, 0, 0,
    5, 10, 10, -30, -30, 10, 10, 5,
    5, 5, 0, 10, 10, 0, 5, 5,
    0, 0, 10, 20, 20, 0, 0, 0,
    0, 0, 0, 10, 10, 0, 0, 0,
    20, 50, 60, 80, 80, 60, 50, 20,
    80, 80, 100, 100, 100, 100, 80, 80,
    0, 0, 0, 0, 0, 0, 0, 0
  },
  // White Knight
  {
    -40, -10, -5, -5, -5, -5, -10, -40,
    -10, -5, 0, 0, 0, 0, -5, -10,
    -5, 0, 5, 5, 5, 5, 0, -5,
    0, 5, 5, 5, 5, 5, 5, 0,
    2, 8, 8, 8, 8, 8, 8, 2,
    0, 2, 5, 5, 5, 5, 2, 0,
    -5, -5, 2, 5, 5, 2, -5, -5,
    -20, -10, -5, 0, 0, -5, -10, -20
  },
  // White Bishop
  {
    -10, -8, -4, -6, -6, -4, 0, -10,
    -6, 6, -2, 4, 4, 0, 6, -6,
    -4, 0, 0, 2, 4, 0, -2, 0,
    0, 4, 8, 4, 4, 8, 4, 0,
    2, 6, 4, 2, 2, 4, 6, 4,
    2, 0, 6, 4, 4, 4, 0, 0,
    2, 0, 2, 0, -2, -2, -2, -4,
    -10, -8, -6, -4, -4, -6, -8, -10
  },
  // White Rook
  {
    0, -6, 8, 20, 20, 2, -6, 0,
    -5, -2, -2, 4, 4, -2, -8, -5,
    -3, 0, 1, 2, 2, 2, 0, -3,
    -1, 0, 0, 0, 0, 0, 0, -1,
    0, 1, 0, 2, 2, 0, 1, 0,
    2, 1, 1, 3, 3, 1, 1, 1,
    6, 8, 10, 10, 10, 10, 8, 6,
    3, 3, 5, 5, 5, 3, 3, 2
  },
  // White Queen
  {
    -3, -5, -3, -1, 0, -2, -5, -1,
    -5, -2, 2, 3, 3, 2, -2, -5,
    -2, 1, 1, 3, 3, 2, 3, -2,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    2, 3, 4, 4, 3, 3, 2, 0,
    -2, 3, 3, 4, 3, 3, 1, -2,
    0, 2, 2, 0, -1, -1, -5, -1
  },
};
 
// score for black pieces is inverted
static bScore endgamevalues[tPiece::P_SIZE][64] = {
  // empty
  {},
  // White King
  {
    -30, -20, -15, -15, -15, -15, -20, -30,
    -20, -10, -5, -5, -5, -5, -10, -20,
    -15, -5, 0, 0, 0, 0, -5, -15,
    -15, -5, 0, 5, 5, 0, -5, -15,
    -15, -5, 0, 5, 5, 0, -5, -15,
    -15, -5, 0, 0, 0, 0, -5, -15,
    -20, -10, -5, -5, -5, -5, -10, -20,
    -30, -20, -15, -15, -15, -15, -20, -30
  },
  // White Pawn
  {
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, -30, -30, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    20, 20, 30, 30, 30, 20, 20, 20,
    40, 50, 60, 80, 80, 60, 50, 40,
    80, 80, 100, 100, 100, 100, 80, 80,
    0, 0, 0, 0, 0, 0, 0, 0
  },
  // White Knight
  {
    -20, -10, -5, 0, 0, -5, -10, -20,
    -10, -5, 0, 0, 0, 0, -5, -10,
    -5, 0, 5, 5, 5, 5, 0, -5,
    0, 0, 5, 20, 20, 5, 0, 0,
    0, 0, 5, 20, 20, 5, 0, 0,
    -5, 0, 5, 5, 5, 5, 0, -5,
    -10, -5, 0, 0, 0, 0, -5, -10,
    -20, -10, -5, 0, 0, -5, -10, -20
  },
  // White Bishop
  {
    -20, -10, -5, 0, 0, -5, -10, -20,
    -10, -5, 0, 0, 0, 0, -5, -10,
    -5, 0, 5, 5, 5, 5, 0, -5,
    0, 0, 5, 20, 20, 5, 0, 0,
    0, 0, 5, 20, 20, 5, 0, 0,
    -5, 0, 5, 5, 5, 5, 0, -5,
    -10, -5, 0, 0, 0, 0, -5, -10,
    -20, -10, -5, 0, 0, -5, -10, -20
  },
  // White Rook
  {
    -20, 10, 0, 0, 0, 0, 10, -20,
    10, 10, 10, 10, 10, 10, 10, 10,
    0, 10, 0, 0, 0, 0, 10, 0,
    0, 10, 0, 0, 0, 0, 10, 0,
    0, 10, 0, 0, 0, 0, 10, 0,
    0, 10, 0, 0, 0, 0, 10, 0,
    10, 10, 10, 10, 10, 10, 10, 10,
    -20, 10, 0, 0, 0, 0, 10, -20
  },
  // White Queen
  {
    -20, -10, -5, 0, 0, -5, -10, -20,
    -10, -5, 0, 0, 0, 0, -5, -10,
    -5, 0, 5, 5, 5, 5, 0, -5,
    0, 0, 5, 20, 20, 5, 0, 0,
    0, 0, 5, 20, 20, 5, 0, 0,
    -5, 0, 5, 5, 5, 5, 0, -5,
    -10, -5, 0, 0, 0, 0, -5, -10,
    -20, -10, -5, 0, 0, -5, -10, -20
  },
};
 
static bScore centerplayvalues[64] = {
  0, 1, 2, 3, 3, 2, 1, 0,
  1, 2, 4, 5, 5, 4, 2, 1,
  2, 4, 6, 7, 7, 6, 4, 2,
  3, 5, 7, 9, 9, 7, 5, 3,
  3, 5, 7, 9, 9, 7, 5, 3,
  2, 4, 6, 7, 7, 6, 4, 2,
  1, 2, 4, 5, 5, 4, 2, 1,
  0, 1, 2, 3, 3, 2, 1, 0
};
 
//-----------------------------------------------------------------------
 
bScore bPositionEvaluation::pieceValue(piece_t const p)
{
  return piecevalues[p];
}
 
bScore bPositionEvaluation::mymove_pieceValue(piece_t const p)
{
  return mymove_piecevalues[p];
}
 
bScore bPositionEvaluation::centerplay_pieceValue(case_t const pos)
{
  return centerplayvalues[pos];
}
 
//-----------------------------------------------------------------------
 
/**
 * Store black piece and field values as negative of whites view
 */
bPositionEvaluation::bPositionEvaluation(std::string const& n)
  : m_name{n}
{
  for (int i = 7; i < tPiece::P_SIZE; i++) {
    piecevalues[i] = piecevalues[i - 6];
    roundedpiecevalues[i] = -roundedpiecevalues[i - 6];
    for (column_t iCol = 0; iCol < 8; iCol++) {
      for (rank_t iRank = 0; iRank < 8; iRank++) {
        if (positionvalues[i - 6][bCase::coordToCase(iCol, 7 - iRank)] != 0) {
          positionvalues[i][bCase::coordToCase(iCol, iRank)]
                  = -positionvalues[i - 6][bCase::coordToCase(iCol, 7 - iRank)];
        }
        if (endgamevalues[i - 6][bCase::coordToCase(iCol, 7 - iRank)] != 0) {
          endgamevalues[i][bCase::coordToCase(iCol, iRank)]
                  = -endgamevalues[i - 6][bCase::coordToCase(iCol, 7 - iRank)];
        }
      }
    }
  }
  for (int i = 0; i < tPiece::P_SIZE; i++)
    mymove_piecevalues[i] = -(piecevalues[i] - piecevalues[tPiece::W_PAWN]) / 10;
}
 
bPositionEvaluation::~bPositionEvaluation()
{
}
 
//-----------------------------------------------------------------------
 
PosEvalPiecesOnly::PosEvalPiecesOnly()
  : bPositionEvaluation("PiecesOnly")
{
}
 
PosEvalPiecesOnly::~PosEvalPiecesOnly()
{
}
 
/** get pure material evaluation of score
 */
bScore PosEvalPiecesOnly::getEvaluation(bBoard const& b) const
{
  gameResult_t ge = isGameEnded(b);
  if (ge != GR_UNKNOWN) return resultToScoreFlag(ge);
 
  bScore value = static_cast<bScore>(belofte::getRandomRange(-5, 5));
  for (case_t iCase = 0; iCase < 64; iCase++) {
    int piece = b.getPiece(iCase);
    if (piece) {
      value += roundedpiecevalues[piece];
    }
  }
  return value;
}
 
//-----------------------------------------------------------------------
 
PosEvalStaticBoard::PosEvalStaticBoard()
  : bPositionEvaluation("StaticBoard")
{
}
 
PosEvalStaticBoard::PosEvalStaticBoard(std::string const& n)
  : bPositionEvaluation(n)
{
}
 
PosEvalStaticBoard::~PosEvalStaticBoard()
{
}
 
/** get material and case related modification of score
 */
bScore PosEvalStaticBoard::getEvaluation(bBoard const& b) const
{
  gameResult_t ge = isGameEnded(b);
  if (ge != GR_UNKNOWN) return resultToScoreFlag(ge);
 
  if (b.getStage() == bGameStage::ST_ENDGAME)
    return getEndgameEvaluation(b);
 
  if (b.getStage() == bGameStage::ST_PAWNENDING)
    return getPawnEndingEvaluation(b);
 
  if (b.getStage() == bGameStage::ST_MATING)
    return getMatingEvaluation(b);
 
  return getRelativeBoardEval(b);
}
 
bScore PosEvalStaticBoard::getRelativeBoardEval(bBoard const& b) const
{
  bScore value = static_cast<bScore>(belofte::getRandomRange(-5, 5));
  bScore white = 0;
  bScore black = 0;
  for (case_t iCase = 0; iCase < 64; iCase++) {
    int piece = b.getPiece(iCase);
    if (piece >= tPiece::B_KING) {
      black += piecevalues[piece];
      value += positionvalues[piece][iCase];
    } else if (piece) {
      white += piecevalues[piece];
      value += positionvalues[piece][iCase];
    }
  }
  return value + (white - black) + (white - black) / (white + black);
}
 
bScore PosEvalStaticBoard::getEndgameEvaluation(bBoard const &b) const
{
  bScore value = static_cast<bScore>(belofte::getRandomRange(-5, 5));
  for (case_t iCase = 0; iCase < 64; iCase++) {
    int piece = b.getPiece(iCase);
    if (piece >= tPiece::B_KING) {
      value -= piecevalues[piece];
      value -= centerplayvalues[iCase];
    } else if (piece) {
      value += piecevalues[piece];
      value += centerplayvalues[iCase];
    }
  }
  return value;
}
 
bScore PosEvalStaticBoard::getPawnEndingEvaluation(bBoard const &b) const
{
  bScore value = static_cast<bScore>(belofte::getRandomRange(-5, 5));
  for (case_t iCase = 0; iCase < 64; iCase++) {
    int piece = b.getPiece(iCase);
    if (piece >= tPiece::B_KING) {
      value -= piecevalues[piece];
    } else if (piece) {
      value += piecevalues[piece];
    }
  }
  return value;
}
 
bScore PosEvalStaticBoard::getMatingEvaluation(bBoard const &b) const
{
  bScore value = static_cast<bScore>(belofte::getRandomRange(-2, 2));
  for (case_t iCase = 0; iCase < 64; iCase++) {
    int piece = b.getPiece(iCase);
    if (piece >= tPiece::B_KING) {
      value -= piecevalues[piece];
    } else if (piece) {
      value += piecevalues[piece];
    }
    value += endgamevalues[piece][iCase];
  }
  return value;
}
 
//-----------------------------------------------------------------------
 
PosEvalPositionalBoard::PosEvalPositionalBoard()
  : PosEvalStaticBoard("PositionalBoard")
{
}
 
PosEvalPositionalBoard::~PosEvalPositionalBoard()
{
}
 
/** get positional evaluation
 */
bScore PosEvalPositionalBoard::getEvaluation(bBoard const& b) const
{
  gameResult_t ge = isGameEnded(b);
  if (ge != GR_UNKNOWN) return resultToScoreFlag(ge);
 
  bScore value;
  if (b.getStage() == bGameStage::ST_ENDGAME)
    value = getEndgameEvaluation(b);
  else if (b.getStage() == bGameStage::ST_PAWNENDING)
    return getPawnEndingEvaluation(b);
  else if (b.getStage() == bGameStage::ST_MATING)
    return getMatingEvaluation(b);
  else
    value = getRelativeBoardEval(b);
 
  value += getKingEvaluation(b);
  value += getPawnEvaluation(b);
  value += getRookEvaluation(b);
  value += getBishopEvaluation(b);
  value += getQueenEvaluation(b);
 
  return value;
}
 
bScore PosEvalPositionalBoard::getKingEvaluation(bBoard const& b) const
{
  bScore value = 0;
 
  if (b.getStage() == bGameStage::ST_OPENING) {
    // add up to 30 centipoints for castle ability, 30 if castled
    if (b.canCastle(tCFlags::WCASTLE_S)) value += 5;
    if (b.canCastle(tCFlags::WCASTLE_S) || b.canCastle(tCFlags::WCASTLE_L)) value += 20;
    if (b.canCastle(tCFlags::WCASTLE_S) && b.canCastle(tCFlags::WCASTLE_L)) value += 5;
    if (b.canCastle(tCFlags::BCASTLE_S)) value -= 5;
    if (b.canCastle(tCFlags::BCASTLE_S) || b.canCastle(tCFlags::BCASTLE_L)) value -= 20;
    if (b.canCastle(tCFlags::BCASTLE_S) && b.canCastle(tCFlags::BCASTLE_L)) value -= 5;
    if (b.castleDoneWhite()) value += 30;
    if (b.castleDoneBlack()) value -= 30;
  }
 
  return value;
}
 
bScore PosEvalPositionalBoard::getPawnEvaluation(bBoard const& b) const
{
  bScore value = 0;
  // TODO: move pawn column occupation to calcPieces
  uint8_t whitePawns[8] = {};
  uint8_t blackPawns[8] = {};
  uint8_t whiteIslands = 0, blackIslands = 0;
 
  // TODO: iterate through whitePieces[] instead
  for (rank_t iRank = 1; iRank < 7; iRank++) {
    for (column_t iCol = 0; iCol < 8; iCol++) {
      piece_t piece = b.getPiece(iCol, iRank);
      if (piece == tPiece::W_PAWN) {
        whitePawns[iCol]++;
      } else if (piece == tPiece::B_PAWN) {
        blackPawns[iCol]++;
      }
    }
  }
 
  // malus for 25 for double pawn, 50 for triple pawn or border double pawn
  for (column_t iCol = 0; iCol < 8; iCol++) {
    if (whitePawns[iCol] > 1) value -= 25 * whitePawns[iCol];
    if (blackPawns[iCol] > 1) value += 25 * blackPawns[iCol];
  }
  if (whitePawns[0] > 1) value -= 25;
  if (whitePawns[7] > 1) value -= 25;
  if (blackPawns[0] > 1) value += 25;
  if (blackPawns[7] > 1) value += 25;
 
  // count adjacent pawn groups, 15 malus for isolated pawn
  // 20 malus for more islands than opponent
  uint8_t bGroup = 0;
  for (column_t iCol = 0; iCol < 8; iCol++) {
    if (whitePawns[iCol]) {
      if (!blackPawns[iCol]) {
        if (whitePassed(b, iCol)) value += 30;
      }
      if (!bGroup) { whiteIslands++; bGroup++; }
    } else {
      if (bGroup == 1) value -= 15; // isolated pawn found
      bGroup = 0;
    }
  }
  // test same for last column
  if (bGroup == 1) value -= 15; // isolated pawn found
  bGroup = 0;
  for (column_t iCol = 0; iCol < 8; iCol++) {
    if (blackPawns[iCol]) {
      if (!whitePawns[iCol]) {
        if (blackPassed(b, iCol)) value -= 30;
      }
      if (!bGroup) { blackIslands++; bGroup++; }
    } else {
      if (bGroup == 1) value += 15; // isolated pawn found
      bGroup = 0;
    }
  }
  // test same for last column
  if (bGroup == 1) value += 15; // isolated pawn found
  if (whiteIslands > blackIslands) value -= 10;
  else if (whiteIslands < blackIslands) value += 10;
 
  return value;
}
 
/** see if pawn has passed, we are only interested in frontmost pawn
 *  function assumes that there is at least a pawn on rank, no checks
 */
bool PosEvalPositionalBoard::whitePassed(bBoard const& b, column_t const iCol) const
{
  bool passed = true;
  rank_t iRank = 6;
  while (iRank) {
    if (b.getPiece(iCol, iRank) == tPiece::W_PAWN) break;
    iRank--;
  }
  if (iCol) {
    for (rank_t i = iRank + 1; i < 7; i++) {
      if (b.getPiece(iCol - 1, i) == tPiece::B_PAWN) return false;
    }
  }
  if (iCol < 7) {
    for (rank_t i = iRank + 1; i < 7; i++) {
      if (b.getPiece(iCol + 1, i) == tPiece::B_PAWN) return false;
    }
  }
  return passed;
}
 
bool PosEvalPositionalBoard::blackPassed(bBoard const& b, column_t const iCol) const
{
  bool passed = true;
  rank_t iRank = 1;
  while (iRank < 6) {
    if (b.getPiece(iCol, iRank) == tPiece::B_PAWN) break;
    iRank++;
  }
  if (iCol) {
    for (rank_t i = iRank - 1; i > 0; i--) {
      if (b.getPiece(iCol - 1, i) == tPiece::W_PAWN) return false;
    }
  }
  if (iCol < 7) {
    for (rank_t i = iRank - 1; i > 0; i--) {
      if (b.getPiece(iCol + 1, i) == tPiece::W_PAWN) return false;
    }
  }
  return passed;
}
 
bScore PosEvalPositionalBoard::getRookEvaluation(bBoard const& b) const
{
  bScore value = 0;
 
  if (b.m_whitePieces[STAT_ROOK].size()) {
    for (unsigned int i=0; i < b.m_whitePieces[STAT_ROOK].size(); i++) {
      rank_t iRank = bCase::rank(b.m_whitePieces[STAT_ROOK][i]);
      column_t iCol = bCase::column(b.m_whitePieces[STAT_ROOK][i]);
      // we need at least 2 to get linked values
      if (i && seesHorVer(b, iCol, iRank, tPiece::W_ROOK)) value += 20;
      if (blackKingSameRankCol(b, iCol, iRank)) value += 25;
      if (sameCol(b, iCol, iRank, tPiece::B_QUEEN)) value += 15;
      else if (sameRank(b, iCol, iRank, tPiece::B_QUEEN)) value += 15;
      value += openLineValWhite(b, iCol, iRank);
      value += rookRankValWhite(b, iRank);
    }
  }
 
  if (b.m_blackPieces[STAT_ROOK].size()) {
    for (unsigned int i=0; i < b.m_blackPieces[STAT_ROOK].size(); i++) {
      rank_t iRank = bCase::rank(b.m_blackPieces[STAT_ROOK][i]);
      column_t iCol = bCase::column(b.m_blackPieces[STAT_ROOK][i]);
      if (i && seesHorVer(b, iCol, iRank, tPiece::B_ROOK)) value -= 20;
      if (whiteKingSameRankCol(b, iCol, iRank)) value -= 25;
      if (sameCol(b, iCol, iRank, tPiece::W_QUEEN)) value -= 15;
      else if (sameRank(b, iCol, iRank, tPiece::W_QUEEN)) value -= 15;
      value -= openLineValBlack(b, iCol, iRank);
      value -= rookRankValBlack(b, iRank);
    }
  }
 
  return value;
}
 
/** check if we see a rook in any direction from this case on
 *  TODO: allow to have indirect match of second rook on same column/rank
 */
bool PosEvalPositionalBoard::seesHorVer(bBoard const& b,
        column_t iCol, rank_t iRank, piece_t const matchPiece) const
{
  column_t c = iCol - 1;
  while (c > 0) {
    if (b.getPiece(c, iRank) == matchPiece) return true;
    if (!b.isFieldEmpty(c, iRank)) break;
    c--;
  }
  c = iCol + 1;
  while (c < 8) {
    if (b.getPiece(c, iRank) == matchPiece) return true;
    if (!b.isFieldEmpty(c, iRank)) break;
    c++;
  }
 
  rank_t r = iRank - 1;
  while (r > 0) {
    if (b.getPiece(iCol, r) == matchPiece) return true;
    if (!b.isFieldEmpty(iCol, r)) break;
    r--;
  }
  r = iRank + 1;
  while (r < 8) {
    if (b.getPiece(iCol, r) == matchPiece) return true;
    if (!b.isFieldEmpty(iCol, r)) break;
    r++;
  }
  return false;
}
 
/**
 * Check if certain piece is on same rank
 * Used to verify rook on Queen rank
 * @return true if yes
 */
bool PosEvalPositionalBoard::sameRank(bBoard const& b, column_t const iCol,
        rank_t const iRank, piece_t const matchPiece) const
{
  column_t c = 0;
  while (c < iCol) {
    if (b.getPiece(c, iRank) == matchPiece) return true;
    c++;
  }
  c = iCol + 1;
  while (c < 8) {
    if (b.getPiece(c, iRank) == matchPiece) return true;
    c++;
  }
  return false;
}
 
/**
 * Check if certain piece is on same column
 * Used to verify rook on Queen rank
 * @return true if yes
 */
bool PosEvalPositionalBoard::sameCol(bBoard const& b, column_t const iCol,
        rank_t const iRank, piece_t const matchPiece) const
{
  rank_t r = 0;
  while (r < iRank) {
    if (b.getPiece(iCol, r) == matchPiece) return true;
    r++;
  }
  r = iRank + r;
  while (r < 8) {
    if (b.getPiece(iCol, r) == matchPiece) return true;
    r++;
  }
  return false;
}
 
/**
 * Check if Queen or Rook is on same rank or column as king
 * @return true if yes
 */
bool PosEvalPositionalBoard::whiteKingSameRankCol(bBoard const& b,
        column_t const iCol, rank_t const iRank) const
{
  if (bCase::column(b.getWhiteKingPos()) == iCol) return true;
  return bCase::rank(b.getWhiteKingPos()) == iRank;
}
 
bool PosEvalPositionalBoard::blackKingSameRankCol(bBoard const& b,
        column_t const iCol, rank_t const iRank) const
{
  if (bCase::column(b.getBlackKingPos()) == iCol) return true;
  return bCase::rank(b.getBlackKingPos()) == iRank;
}
 
/** see if rook is on open or semi-open line
 * @bug does not see if behind piece
 */
bScore PosEvalPositionalBoard::openLineValWhite(bBoard const& b, column_t const iCol,
        rank_t const iRank) const
{
  rank_t r = iRank + 1;
  while (r < 7) {
    if (b.getPiece(iCol, r) == tPiece::W_PAWN) return 0;
    if (b.getPiece(iCol, r) == tPiece::B_PAWN) return 5;
    r++;
  }
  return 10;
}
 
bScore PosEvalPositionalBoard::openLineValBlack(bBoard const& b, column_t const iCol,
        rank_t const iRank) const
{
  rank_t r = iRank - 1;
  while (r > 0) {
    if (b.getPiece(iCol, r) == tPiece::B_PAWN) return 0;
    if (b.getPiece(iCol, r) == tPiece::W_PAWN) return 5;
    r--;
  }
  return 10;
}
 
bScore PosEvalPositionalBoard::rookRankValWhite(bBoard const& b,
        rank_t const iRank) const
{
  if ((iRank == 0) || (iRank == 7)) return 0;
  bScore value = 0;
  for (column_t iCol = 0; iCol < 8; iCol++) {
    if (b.getPiece(iCol, iRank) == tPiece::B_PAWN) value += 2;
  }
  return value;
}
 
bScore PosEvalPositionalBoard::rookRankValBlack(bBoard const& b,
        rank_t const iRank) const
{
  if ((iRank == 0) || (iRank == 7)) return 0;
  bScore value = 0;
  for (column_t iCol = 0; iCol < 8; iCol++) {
    if (b.getPiece(iCol, iRank) == tPiece::W_PAWN) value += 2;
  }
  return value;
}
 
bScore PosEvalPositionalBoard::getBishopEvaluation(bBoard const& b) const
{
  bScore value = 0;
 
  if (b.m_whitePieces[STAT_BISHOP].size()) {
    for (auto const& v : b.m_whitePieces[STAT_BISHOP]) {
      rank_t iRank = bCase::rank(v);
      column_t iCol = bCase::column(v);
      if (sameColourBlackKing(b, v)) {
        value += 3;
        if (sameDiagonal(b, iCol, iRank, tPiece::B_KING)) value += 7;
      }
      if (sameDiagonal(b, iCol, iRank, tPiece::B_QUEEN)) value += 5;
      else if (sameColour(b, v, tPiece::B_QUEEN)) value += 2;
    }
  }
 
  if (b.m_blackPieces[STAT_BISHOP].size()) {
    for (auto const& v : b.m_blackPieces[STAT_BISHOP]) {
      rank_t iRank = bCase::rank(v);
      column_t iCol = bCase::column(v);
      if (sameColourWhiteKing(b, v)) {
        value -= 3;
        if (sameDiagonal(b, iCol, iRank, tPiece::W_KING)) value -= 7;
      }
      if (sameDiagonal(b, iCol, iRank, tPiece::W_QUEEN)) value -= 5;
      else if (sameColour(b, v, tPiece::W_QUEEN)) value -= 2;
    }
  }
 
  return value;
}
 
bool PosEvalPositionalBoard::sameDiagonal(bBoard const& b, column_t const iCol,
        rank_t const iRank, piece_t const matchPiece) const
{
  for (int8_t i = 1; i < 7; i++) {
    if (b.getPieceCtl(iCol - i, iRank - i) == matchPiece) return true;
    if (b.getPieceCtl(iCol - i, iRank + i) == matchPiece) return true;
    if (b.getPieceCtl(iCol + i, iRank - i) == matchPiece) return true;
    if (b.getPieceCtl(iCol + i, iRank + i) == matchPiece) return true;
  }
  return false;
}
 
/** see if matching piece is of same colour as original piece
 * TODO: loop through piecelist instead of 64 fields
 */
bool PosEvalPositionalBoard::sameColour(bBoard const& b, case_t const c,
        piece_t const matchPiece) const
{
  uint8_t pieceColour = whitefields[c];
  for (case_t iCase = 0; iCase < 64; iCase++) {
    if (b.getPiece(iCase) == matchPiece) {
      return whitefields[iCase] == pieceColour;
    }
  }
  return false;
}
 
/** see if matching king is of same colour as original piece
 */
bool PosEvalPositionalBoard::sameColourWhiteKing(bBoard const& b,
        case_t const c) const
{
  return whitefields[b.getWhiteKingPos()] == whitefields[c];
}
 
/** see if matching king is of same colour as original piece
 */
bool PosEvalPositionalBoard::sameColourBlackKing(bBoard const& b,
        case_t const c) const
{
  return whitefields[b.getBlackKingPos()] == whitefields[c];
}
 
bScore PosEvalPositionalBoard::getQueenEvaluation(bBoard const& b) const
{
  bScore value = 0;
 
  if (b.m_whitePieces[STAT_QUEEN].size()) {
    for (auto const& v : b.m_whitePieces[STAT_QUEEN]) {
      rank_t iRank = bCase::rank(v);
      column_t iCol = bCase::column(v);
      if (sameDiagonal(b, iCol, iRank, tPiece::B_KING)) value += 5;
      if (blackKingSameRankCol(b, iCol, iRank)) value += 5;
    }
  }
 
  if (b.m_blackPieces[STAT_QUEEN].size()) {
    for (auto const& v : b.m_blackPieces[STAT_QUEEN]) {
      rank_t iRank = bCase::rank(v);
      column_t iCol = bCase::column(v);
      if (sameDiagonal(b, iCol, iRank, tPiece::W_KING)) value -= 5;
      if (whiteKingSameRankCol(b, iCol, iRank)) value -= 5;
    }
  }
 
  return value;
}
 
// eof