Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Napoleon - evaluation.cpp

evaluation.cpp

 Caricato da: Crybot
Scarica il programma completo

  1. #include "evaluation.h"
  2. #include "utils.h"
  3. #include "board.h"
  4. #include "piece.h"
  5.  
  6. namespace Napoleon
  7. {
  8.         int Evaluation::pawnSquareValue[64] =
  9.         {
  10.                 0,  0,  0,  0,  0,  0,  0,  0,
  11.                 5, 10, 15,-20,-20, 15, 10,  5,
  12.                 5, -5,-10,  0, 0,-10, -5,  5,
  13.                 0,  0,  0, 20, 20,  0,  0,  0,
  14.                 5,  5, 10, 25, 25, 10,  5,  5,
  15.                 10, 10, 20, 30, 30, 20, 10, 10,
  16.                 50, 50, 50, 50, 50, 50, 50, 50,
  17.                 0,  0,  0,  0,  0,  0,  0,  0
  18.         };
  19.  
  20.         int Evaluation::knightSquareValue[64] =
  21.         {
  22.                 -50,-20,-30,-30,-30,-30,-20,-50,
  23.                 -40,-20,  0,  0,  0,  0,-20,-40,
  24.                 -30,  0, 10, 15, 15, 10,  0,-30,
  25.                 -30,  5, 15, 20, 20, 15,  5,-30,
  26.                 -30,  0, 15, 20, 20, 15,  0,-30,
  27.                 -30,  5, 10, 15, 15, 10,  5,-30,
  28.                 -40,-20,  0,  5,  5,  0,-20,-40,
  29.                 -50,-40,-30,-30,-30,-30,-40,-50,
  30.         };
  31.  
  32.         int Evaluation::bishopSquareValue[64] =
  33.         {
  34.  
  35.                 -20,-10,-10,-10,-10,-10,-10,-20,
  36.                 -10,  5,  0,  0,  0,  0,  5,-10,
  37.                 -10, 10, 10, 10, 10, 10, 10,-10,
  38.                 -10,  0, 20, 10, 10, 20,  0,-10,
  39.                 -10,  5,  5, 10, 10,  5,  5,-10,
  40.                 -10,  0,  5, 10, 10,  5,  0,-10,
  41.                 -10,  0,  0,  0,  0,  0,  0,-10,
  42.                 -20,-10,-10,-10,-10,-10,-10,-20,
  43.         };
  44.  
  45.         int Evaluation::rookSquareValue[64] =
  46.         {
  47.                 0,  0,  0,  5,  5,  0,  0,  0,
  48.                 -5,  0,  0,  0,  0,  0,  0, -5,
  49.                 -5,  0,  0,  0,  0,  0,  0, -5,
  50.                 -5,  0,  0,  0,  0,  0,  0, -5,
  51.                 -5,  0,  0,  0,  0,  0,  0, -5,
  52.                 -5,  0,  0,  0,  0,  0,  0, -5,
  53.                 5,  10, 20, 20, 20, 20, 10, 5,
  54.                 0,   0,  0,  0,  0,  0,  0, 0
  55.         };
  56.  
  57.         int Evaluation::queenSquareValue[64] =
  58.         {
  59.                 -20, -5, -5,  0,  0, -5, -5, -20,
  60.                 -10,  0,  0,  0,  0,  0,  0, -10,
  61.                 -5,   0,  5,  5,  5,  5,  0,  -5,
  62.                 -5,   0,  5,  5,  5,  5,  0,  -5,
  63.                 -5,   0,  5,  5,  5,  5,  0,  -5,
  64.                 -5,   0,  0,  0,  0,  0,  0,  -5,
  65.                 0,   5, 10, 10, 10, 10,  5,   0,
  66.                 0,   0,  0,  0,  0,  0,  0,   0
  67.         };
  68.  
  69.         int Evaluation::kingMiddleGame[64] =
  70.         {
  71.                 20, 30, 10,  0,  0, 10, 35, 20,
  72.                 20, 10,  0,  0,  0,  0, 10, 20,
  73.                 -10,-20,-20,-20,-20,-20,-20,-10,
  74.                 -20,-30,-30,-40,-40,-30,-30,-20,
  75.                 -30,-40,-40,-50,-50,-40,-40,-30,
  76.                 -30,-40,-40,-50,-50,-40,-40,-30,
  77.                 -30,-40,-40,-50,-50,-40,-40,-30,
  78.                 -30,-40,-40,-50,-50,-40,-40,-30
  79.         };
  80.  
  81.         int Evaluation::kingEndGame[64] =
  82.         {
  83.                 -50,-30,-30,-30,-30,-30,-30,-50
  84.                 -30,-30,  0,  0,  0,  0,-30,-30,
  85.                 -30,-10, 20, 30, 30, 20,-10,-30,
  86.                 -30,-10, 30, 40, 40, 30,-10,-30,
  87.                 -30,-10, 30, 40, 40, 30,-10,-30,
  88.                 -30,-10, 20, 30, 30, 20,-10,-30,
  89.                 -30,-20,-10,  0,  0,-10,-20,-30,
  90.                 -50,-40,-30,-20,-20,-30,-40,-50
  91.         };
  92.  
  93.         int Evaluation::multiPawnP[8] = { 0, 0, 20, 50, 100, 100, 100, 100 };
  94.  
  95.         int Evaluation::Evaluate(Board & board)
  96.         {
  97.                 using namespace Utils::BitBoard;
  98.                 using namespace PieceColor;
  99.                 using namespace Constants::Squares;
  100.  
  101.                 int score = 0;
  102.  
  103.                 // material evaluation
  104.                 int material = board.Material(White) - board.Material(Black);
  105.  
  106.                 // Piece Square Value evaluation
  107.                 int wPST = board.PstValue(White);
  108.                 int bPST = board.PstValue(Black);
  109.  
  110.                 score += material + (wPST - bPST);
  111.  
  112.                 // premature queen development
  113.                 if (!board.IsOnSquare(White, PieceType::Queen, IntD1))
  114.                         if (board.Material(White) > Constants::Eval::MiddleGameMat)
  115.                                 score -= 10;
  116.  
  117.                 if (!board.IsOnSquare(Black, PieceType::Queen, IntD8))
  118.                         if (board.Material(Black) > Constants::Eval::MiddleGameMat)
  119.                                 score += 10;
  120.  
  121.                 // tempo bonus
  122.                 if (board.SideToMove == White)
  123.                         score += 5;
  124.                 else
  125.                         score -= 5;
  126.  
  127.                 /* PAWN STRUCTURE */
  128.  
  129.                 // doubled/tripled pawns evaluation
  130.                 for (File f = 0; f<8; f++)
  131.                 {
  132.                         score -= multiPawnP[board.PawnsOnFile(White, f)];
  133.                         score += multiPawnP[board.PawnsOnFile(Black, f)];
  134.                 }
  135.  
  136.                 // mobility evaluation
  137.                 Piece piece;
  138.                 for (Napoleon::Square sq = 0; sq<64; sq++)
  139.                 {
  140.                         piece = board.PieceSet[sq];
  141.                         if (piece.Type != PieceType::None)
  142.                         {
  143.                                 if (piece.Color == White)
  144.                                         score += EvaluatePiece(piece, sq, board);
  145.                                 else
  146.                                         score -= EvaluatePiece(piece, sq, board);
  147.                         }
  148.                 }
  149.  
  150.                 return score * (1-(board.SideToMove*2));
  151.         }
  152.  
  153.         int Evaluation::EvaluatePiece(Piece piece, Square square, Board& board)
  154.         {
  155.                 using namespace Utils::BitBoard;
  156.                 BitBoard b = 0;
  157.  
  158.                 switch(piece.Type)
  159.                 {
  160.                 case PieceType::Knight:
  161.                         b = MoveDatabase::KnightAttacks[square] & ~board.GetPieces(piece.Color);
  162.                         return 0.3*PopCount(b);
  163.  
  164.                 case PieceType::Bishop:
  165.                         b = (MoveDatabase::GetA1H8DiagonalAttacks(board.OccupiedSquares, square)
  166.                                 | MoveDatabase::GetH1A8DiagonalAttacks(board.OccupiedSquares, square))
  167.                                 & ~board.GetPieces(piece.Color);
  168.  
  169.                         return 0.5*PopCount(b);
  170.  
  171.                 case PieceType::Rook:
  172.                         b = (MoveDatabase::GetFileAttacks(board.OccupiedSquares, square)
  173.                                 | MoveDatabase::GetRankAttacks(board.OccupiedSquares, square))
  174.                                 & ~board.GetPieces(piece.Color);
  175.  
  176.                         return 0.1*PopCount(b);
  177.  
  178.                 default:
  179.                         return 0;
  180.                 }
  181.         }
  182.  
  183.         int Evaluation::CalculatePST(Piece piece, Square square, Board& board)
  184.         {
  185.                 using namespace Utils::Square;
  186.                 using namespace PieceColor;
  187.                 using namespace Constants::Squares;
  188.  
  189.                 switch(piece.Type)
  190.                 {
  191.                 case PieceType::Pawn:
  192.                         return piece.Color ==  White ? pawnSquareValue[square] : pawnSquareValue[GetSquareIndex(square % 8, 7 - (square/8))];
  193.  
  194.                 case PieceType::Knight:
  195.                         return piece.Color == White ? knightSquareValue[square] : knightSquareValue[GetSquareIndex(square % 8, 7 - (square/8))];
  196.  
  197.                 case PieceType::Bishop:
  198.                         return piece.Color == White ? bishopSquareValue[square] : bishopSquareValue[GetSquareIndex(square % 8, 7 - (square/8))];
  199.  
  200.                 case PieceType::Rook:
  201.                         return piece.Color == White ? rookSquareValue[square] : rookSquareValue[GetSquareIndex(square % 8, 7 - (square/8))];
  202.  
  203.                 case PieceType::Queen:
  204.                         return piece.Color == White ? queenSquareValue[square] : queenSquareValue[GetSquareIndex(square % 8, 7 - (square/8))];
  205.  
  206.                 case PieceType::King:
  207.                         if (board.Material(piece.Color) > Constants::Eval::EndGameMat)
  208.                                 return piece.Color == White ? kingMiddleGame[square] : kingMiddleGame[GetSquareIndex(square % 8, 7 - (square/8))];
  209.                         else
  210.                                 return piece.Color == White ? kingEndGame[square] : kingEndGame[GetSquareIndex(square % 8, 7 - (square/8))];
  211.                 }
  212.  
  213.                 return 0;
  214.         }
  215. }