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"
 
namespace belofte {
  extern bWhiteKing const* cWhiteKingClass;
  extern bBlackKing const* cBlackKingClass;
}
 
namespace belofteeval {
 
  static constexpr uint8_t fieldcolours[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
  };
 
  extern bScore piecevalues[];
  extern const bScore centerplayvalues[];
  extern bScore piecevalues_movepenalty[];
}
 
//-----------------------------------------------------------------------
 
/**
 * @static Class static function
 * See if board is in finite state, meaning game is ended
 * @param b board is a reference, can be updated
 * @return mate, stalemate, draw or further evaluation required (GR_UNKNOWN)
 * @todo when a move has been registered on board, no need to check for move generation
 */
gameResult_t bPositionEvaluation::gameEndedResult(bBoard const& b)
{
  // check for 3 and 4 piece combinations that are theoretic draw
  if (insufficientMaterial(b)) return GR_DRAW_LACKMATERIAL;
 
  if (b.getPly50Moves() >= 100) return GR_DRAW_50;
 
  bBasicBoard bb(b);
  bMoveList ml;
  if (!ml.atLeastOneMovePossible(bb)) {
    if (b.whiteToMove()) {
      if (belofte::cWhiteKingClass->isAttacked(bb, bb.getWhiteKingPos())) {
        return GR_BLACKMATES;
      }
      return GR_DRAW_STALEMATE;
    } else {
      if (belofte::cBlackKingClass->isAttacked(bb, bb.getBlackKingPos())) {
        return GR_WHITEMATES;
      }
      return GR_DRAW_STALEMATE;
    }
  }
  if (threeFoldRepetition(b)) return GR_DRAW_THREEFOLD;
 
  return GR_UNKNOWN;
}
 
/**
 * @static Class static function
 * convert all draw scores to SCORE_THEORETIC_DRAW
 * @return -SCORE_MATE, SCORE_MATE or SCORE_THEORETIC_DRAW
 */
bScore bPositionEvaluation::resultToScoreFlag(gameResult_t const gr)
{
  if (gr == GR_BLACKMATES) return -SCORE_MATE;
  else if (gr == GR_WHITEMATES) return SCORE_MATE;
  return SCORE_THEORETIC_DRAW;
}
 
/**
 * @static Class static function
 * test if draw by insufficient material, 2 pieces or 3-4 pieces
 * other >3 pieces, never material draw ("KNKN", "KNKB", "KBKN" are not draws by FIDE rule)
 * @return true if insufficient material to mate
 */
bool bPositionEvaluation::insufficientMaterial(bBoard const& b)
{
  if (b.pieceCount() > 4) return false;
  if (b.pieceCount() == 2) return true; // only KK, so always draw
 
  // bishop masks
  uint8_t whitemask = 0;
  uint8_t blackmask = 0;
 
  uint_fast8_t knight = 0;
  uint_fast8_t whitebishop = 0;
  uint_fast8_t blackbishop = 0;
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wswitch"
#pragma GCC diagnostic ignored "-Wswitch-enum"
#pragma GCC diagnostic ignored "-Wswitch-default"
#endif
 
  for (case_t iCase = 0; iCase < 64; ++iCase) {
    piece_t piece = b.getPiece(iCase);
 
    switch (piece) {
      case tPiece::W_PAWN:
      case tPiece::B_PAWN:
      case tPiece::W_ROOK:
      case tPiece::B_ROOK:
      case tPiece::W_QUEEN:
      case tPiece::B_QUEEN:
        // any of these means not insufficient material
        return false;
 
    // special accounting
    case tPiece::W_KNIGHT:
    case tPiece::B_KNIGHT:
      ++knight;
      break;
 
    case tPiece::W_BISHOP:
      ++whitebishop;
      whitemask |= belofteeval::fieldcolours[iCase];
      break;
    case tPiece::B_BISHOP:
      ++blackbishop;
      blackmask |= belofteeval::fieldcolours[iCase];
      break;
    }
  }
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
  // no rook/pawn/queen present, only 3 pieces
  // draw positions: "KK", "KNK", "KKN", "KBK", "KKB"
  if (b.pieceCount() == 3) return false;
 
  if (whitebishop && blackbishop) {
    // "KBKB" is draw only with same bishops by FIDE rule
    // same colour bishop is not insufficient material
    return whitemask == blackmask;
  }
 
  /// other >3 pieces
 
  if (!knight && (whitebishop || blackbishop)) {
    /// @remark special case of KBBK with same colour bishop is not known by FIDE
    /// but here regarded as draw
    /// 4 pieces present, 2 bishops of same colour means insufficient materiel
    return (whitemask + blackmask != 3);
  }
 
  // 2 knights present, or one knight and one bishop
  return false;
}
 
/**
 * @static Class static function
 */
int8_t bPositionEvaluation::nFoldRepetition(bBoard const& b)
{
  int8_t nMovesSinceLastPawnMove = static_cast<int8_t>(b.getPly50Moves());
  if (nMovesSinceLastPawnMove < 4) return 1;
 
  int8_t nRepetitionCount = 1;
  hashkey_t currentHash = b.getHash();
  hashkey_t nPieceCntFlag = currentHash & HASH_ODDMATERIAL;
 
  /// @todo we need to iterate through positions to get here,
  /// and not only on gamehistory
  positions_t const& positions = Game()->getPositions();
 
  std::vector<bBoard>::const_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;
 
  /// @todo speedup add changes in flag for castle rights to break out
  /// b.hasCastleRights(tCFlags::WCASTLE_S | tCFlags::WCASTLE_L
  ///                   | tCFlags::BCASTLE_S | tCFlags::BCASTLE_L)
  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 (odd material bit flips)
    if (((*it).getHash() & HASH_ODDMATERIAL) != nPieceCntFlag) break;
    ++it;
  }
 
  return nRepetitionCount;
}
 
/**
 * @static Class static function
 */
bool bPositionEvaluation::twoFoldRepetition(bBoard const& b)
{
  if (b.getPly50Moves() < 4) return false;
  return (nFoldRepetition(b) > 1);
}
 
/**
 * @static Class static function
 */
bool bPositionEvaluation::threeFoldRepetition(bBoard const& b)
{
  if (b.getPly50Moves() < 6) return false;
  return (nFoldRepetition(b) > 2);
}
 
//-----------------------------------------------------------------------
 
namespace belofteeval {
 
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
};
 
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
};
 
bScore piecevalues_movepenalty[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
  },
};
 
bScore const 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
};
 
}
 
//-----------------------------------------------------------------------
 
/**
 * Store black piece and field values as negative of whites view
 */
bPositionEvaluation::bPositionEvaluation(std::string&& s)
  : m_name{std::move(s)}
{
  for (int i = 7; i < tPiece::P_SIZE; ++i) {
    belofteeval::piecevalues[i] = belofteeval::piecevalues[i - 6];
    belofteeval::roundedpiecevalues[i] = -belofteeval::roundedpiecevalues[i - 6];
    for (column_t iCol = 0; iCol < 8; ++iCol) {
      for (rank_t iRank = 0; iRank < 8; ++iRank) {
        if (belofteeval::positionvalues[i - 6][bCase::coordToCase(iCol, 7 - iRank)] != 0) {
          belofteeval::positionvalues[i][bCase::coordToCase(iCol, iRank)]
                  = -belofteeval::positionvalues[i - 6][bCase::coordToCase(iCol, 7 - iRank)];
        }
        if (belofteeval::endgamevalues[i - 6][bCase::coordToCase(iCol, 7 - iRank)] != 0) {
          belofteeval::endgamevalues[i][bCase::coordToCase(iCol, iRank)]
                  = -belofteeval::endgamevalues[i - 6][bCase::coordToCase(iCol, 7 - iRank)];
        }
      }
    }
  }
  for (int i = 0; i < tPiece::P_SIZE; ++i)
    belofteeval::piecevalues_movepenalty[i]
      = -(belofteeval::piecevalues[i] - belofteeval::piecevalues[tPiece::W_PAWN]) / 10;
}
 
/**
 * get final score (+-SCORE_MATE, SCORE_THEORETIC_DRAW) or 0
 */
bScore bPositionEvaluation::getEvaluation(bBoard const& b, gameResult_t gr) const
{
  if (gr == GR_UNSET) gr = gameEndedResult(b);
  if (gr != GR_UNKNOWN) return resultToScoreFlag(gr);
 
  return 0;
}
 
//-----------------------------------------------------------------------
 
/**
 * get pure material evaluation of score from whites view
 */
bScore PosEvalPiecesOnly::getEvaluation(bBoard const& b, gameResult_t gr) const
{
  if (gr == GR_UNSET) gr = gameEndedResult(b);
  if (gr != GR_UNKNOWN) return resultToScoreFlag(gr);
 
  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 += belofteeval::roundedpiecevalues[piece];
    }
  }
  return value;
}
 
//-----------------------------------------------------------------------
 
/**
 * get material and case related modification of score from whites view
 */
bScore PosEvalStaticBoard::getEvaluation(bBoard const& b, gameResult_t gr) const
{
  if (gr == GR_UNSET) gr = gameEndedResult(b);
  if (gr != GR_UNKNOWN) return resultToScoreFlag(gr);
 
  if (b.getGameStage() == bGameStage::ST_ENDGAME)
    return getEndgameEvaluation(b);
 
  if (b.getGameStage() == bGameStage::ST_PAWNENDING)
    return getPawnEndingEvaluation(b);
 
  if (b.getGameStage() == bGameStage::ST_MATING)
    return getMatingEvaluation(b);
 
  return getRelativeBoardEval(b);
}
 
bScore PosEvalStaticBoard::getRelativeBoardEval(bBoard const& b)
{
  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 += belofteeval::piecevalues[piece];
      value += belofteeval::positionvalues[piece][iCase];
    } else if (piece) {
      white += belofteeval::piecevalues[piece];
      value += belofteeval::positionvalues[piece][iCase];
    }
  }
  return value + (white - black) + ((white - black) / (white + black));
}
 
bScore PosEvalStaticBoard::getEndgameEvaluation(bBoard const &b)
{
  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 -= belofteeval::piecevalues[piece];
      value -= belofteeval::centerplayvalues[iCase];
    } else if (piece) {
      value += belofteeval::piecevalues[piece];
      value += belofteeval::centerplayvalues[iCase];
    }
  }
  return value;
}
 
bScore PosEvalStaticBoard::getPawnEndingEvaluation(bBoard const &b)
{
  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 -= belofteeval::piecevalues[piece];
    } else if (piece) {
      value += belofteeval::piecevalues[piece];
    }
  }
  return value;
}
 
bScore PosEvalStaticBoard::getMatingEvaluation(bBoard const &b)
{
  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 -= belofteeval::piecevalues[piece];
    } else if (piece) {
      value += belofteeval::piecevalues[piece];
    }
    value += belofteeval::endgamevalues[piece][iCase];
  }
  return value;
}
 
//-----------------------------------------------------------------------
 
/**
 * get positional evaluation from whites view
 */
bScore PosEvalPositionalBoard::getEvaluation(bBoard const& b, gameResult_t gr) const
{
  if (gr == GR_UNSET) gr = gameEndedResult(b);
  if (gr != GR_UNKNOWN) return resultToScoreFlag(gr);
 
  bScore value;
  if (b.getGameStage() == bGameStage::ST_ENDGAME)
    value = getEndgameEvaluation(b);
  else if (b.getGameStage() == bGameStage::ST_PAWNENDING)
    return getPawnEndingEvaluation(b);
  else if (b.getGameStage() == 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)
{
  bScore value = 0;
 
  if (b.getGameStage() == bGameStage::ST_OPENING) {
    // add up to 30 centipoints for castle ability, 30 if castled { }
    if (b.whiteHasCastled()) { value += 30; }
    else if (b.hasCastleRights(tCFlags::WCASTLE_S | tCFlags::WCASTLE_L)) {
      // has short or long rights
      if (b.hasCastleRights(tCFlags::WCASTLE_S)) {
        if (b.hasCastleRights(tCFlags::WCASTLE_L)) {
          value += 30; // short and long castle rights
        } else {
          value += 25; // short only
        }
      } else {
        value += 20; // long only
      }
    }
 
    if (b.blackHasCastled()) { value -= 30; }
    else if (b.hasCastleRights(tCFlags::BCASTLE_S | tCFlags::BCASTLE_L)) {
      // has short or long rights
      if (b.hasCastleRights(tCFlags::BCASTLE_S)) {
        if (b.hasCastleRights(tCFlags::BCASTLE_L)) {
          value -= 30; // short and long castle rights
        } else {
          value -= 25; // short only
        }
      } else {
        value -= 20; // long only
      }
    }
  }
 
  return value;
}
 
bScore PosEvalPositionalBoard::getPawnEvaluation(bBoard const& b)
{
  bScore value = 0;
  /// @todo move pawn column occupation to calcMinorPieces
  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;
}
 
/**
 * @static Class static function
 * 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)
{
  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)
{
  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)
{
  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;
}
 
/**
 * @static Class static function
 * 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)
{
  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;
}
 
/**
 * @static Class static function
 * 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)
{
  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;
}
 
/**
 * @static Class static function
 * 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)
{
  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;
}
 
/**
 * @static Class static function
 * 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)
{
  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)
{
  if (bCase::column(b.getBlackKingPos()) == iCol) return true;
  return bCase::rank(b.getBlackKingPos()) == iRank;
}
 
/**
 * @static Class static function
 * see if rook is on open or semi-open line
 */
bScore PosEvalPositionalBoard::openLineValWhite(bBoard const& b, column_t const iCol,
        rank_t iRank)
{
  while (++iRank < 7) {
    piece_t piece = b.getPiece(iCol, iRank);
    if (piece == tPiece::W_PAWN) return 0;
    if (piece == tPiece::B_PAWN) return 5;
  }
  return 10;
}
 
/**
 * @static Class static function
 * see if rook is on open or semi-open line
 */
bScore PosEvalPositionalBoard::openLineValBlack(bBoard const& b, column_t const iCol,
        rank_t iRank)
{
  while (--iRank > 0) {
    piece_t piece = b.getPiece(iCol, iRank);
    if (piece == tPiece::B_PAWN) return 0;
    if (piece == tPiece::W_PAWN) return 5;
  }
  return 10;
}
 
bScore PosEvalPositionalBoard::rookRankValWhite(bBoard const& b,
        rank_t const iRank)
{
  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)
{
  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)
{
  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;
}
 
/**
 * @static Class static function
 */
bool PosEvalPositionalBoard::sameDiagonal(bBoard const& b, column_t const iCol,
        rank_t const iRank, piece_t const matchPiece)
{
  int8_t nMax = iCol;
  for (int8_t i = 1; i <= nMax; ++i) {
    if (b.getPieceCtl(iCol - i, iRank - i) == matchPiece) return true;
    if (b.getPieceCtl(iCol - i, iRank + i) == matchPiece) return true;
  }
  nMax = 7 - iCol;
  for (int8_t i = 1; i <= nMax; ++i) {
    if (b.getPieceCtl(iCol + i, iRank - i) == matchPiece) return true;
    if (b.getPieceCtl(iCol + i, iRank + i) == matchPiece) return true;
  }
  return false;
}
 
/**
 * @static Class static function
 * 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)
{
  uint8_t pieceColour = belofteeval::fieldcolours[c];
  for (case_t iCase = 0; iCase < 64; iCase++) {
    if (b.getPiece(iCase) == matchPiece) {
      return belofteeval::fieldcolours[iCase] == pieceColour;
    }
  }
  return false;
}
 
/**
 * @static Class static function
 * see if matching king is of same colour as original piece
 */
bool PosEvalPositionalBoard::sameColourWhiteKing(bBoard const& b,
        case_t const iCol)
{
  return belofteeval::fieldcolours[b.getWhiteKingPos()] == belofteeval::fieldcolours[iCol];
}
 
/**
 * @static Class static function
 * see if matching king is of same colour as original piece
 */
bool PosEvalPositionalBoard::sameColourBlackKing(bBoard const& b,
        case_t const iCol)
{
  return belofteeval::fieldcolours[b.getBlackKingPos()] == belofteeval::fieldcolours[iCol];
}
 
bScore PosEvalPositionalBoard::getQueenEvaluation(bBoard const& b)
{
  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 (PosEvalPositionalBoard::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 (PosEvalPositionalBoard::sameDiagonal(b, iCol, iRank, tPiece::W_KING)) value -= 5;
      if (whiteKingSameRankCol(b, iCol, iRank)) value -= 5;
    }
  }
 
  return value;
}
 
// eof