Some code reformat in evaluate_pieces

No functional change.

src/evaluate.cpp

@@ -150,37 +150,23 @@ namespace {
 
   #undef S
 
-  const Score BishopPinBonus = make_score(66, 11);
-
-  // Bonus for having the side to move (modified by Joona Kiiski)
   const Score Tempo = make_score(24, 11);
 
-  // Rooks and queens on the 7th rank
+  const Score BishopPinBonus         = make_score(66, 11);
   const Score RookOn7thBonus         = make_score(11, 20);
   const Score QueenOn7thBonus        = make_score( 3,  8);
-
-  // Rooks and queens attacking pawns on the same rank
   const Score RookOnPawnBonus        = make_score(10, 28);
   const Score QueenOnPawnBonus       = make_score( 4, 20);
-
-  // Rooks on open files (modified by Joona Kiiski)
   const Score RookOpenFileBonus      = make_score(43, 21);
   const Score RookHalfOpenFileBonus  = make_score(19, 10);
-
-  // Penalty for rooks trapped inside a friendly king which has lost the
-  // right to castle.
-  const Value TrappedRookPenalty = Value(180);
-
-  // Penalty for bishop with pawns on the same coloured squares
   const Score BishopPawnsPenalty     = make_score(8, 12);
+  const Score UndefendedMinorPenalty = make_score(25, 10);
+  const Score TrappedRookPenalty     = make_score(90, 0);
 
   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
   // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
   // happen in Chess960 games.
-  const Score TrappedBishopA1H1Penalty = make_score(100, 100);
+  const Score TrappedBishopA1H1Penalty = make_score(50, 50);
-
-  // Penalty for an undefended bishop or knight
-  const Score UndefendedMinorPenalty = make_score(25, 10);
 
   // The SpaceMask[Color] contains the area of the board which is considered
   // by the space evaluation. In the middle game, each side is given a bonus
@@ -535,9 +521,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
   Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score& mobility, Bitboard mobilityArea) {
 
     Bitboard b;
-    Square s, ksq;
+    Square s;
-    int mob;
-    File f;
     Score score = SCORE_ZERO;
 
     const Color Them = (Us == WHITE ? BLACK : WHITE);
@@ -548,14 +532,9 @@ Value do_evaluate(const Position& pos, Value& margin) {
     while ((s = *pl++) != SQ_NONE)
     {
         // Find attacked squares, including x-ray attacks for bishops and rooks
-        if (Piece == KNIGHT || Piece == QUEEN)
+        b = Piece == BISHOP ? attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN))
-            b = pos.attacks_from<Piece>(s);
+          : Piece ==   ROOK ? attacks_bb<  ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN))
-        else if (Piece == BISHOP)
+                            : pos.attacks_from<Piece>(s);
-            b = attacks_bb<BISHOP>(s, pos.pieces() ^ pos.pieces(Us, QUEEN));
-        else if (Piece == ROOK)
-            b = attacks_bb<ROOK>(s, pos.pieces() ^ pos.pieces(Us, ROOK, QUEEN));
-        else
-            assert(false);
 
         ei.attackedBy[Us][Piece] |= b;
 
@@ -568,9 +547,7 @@ Value do_evaluate(const Position& pos, Value& margin) {
                 ei.kingAdjacentZoneAttacksCount[Us] += popcount<Max15>(bb);
         }
 
-        mob = (Piece != QUEEN ? popcount<Max15>(b & mobilityArea)
+        int mob = popcount<Piece == QUEEN ? Full : Max15>(b & mobilityArea);
-                              : popcount<Full >(b & mobilityArea));
-
         mobility += MobilityBonus[Piece][mob];
 
         // Decrease score if we are attacked by an enemy pawn. Remaining part
@@ -578,8 +555,8 @@ Value do_evaluate(const Position& pos, Value& margin) {
         if (ei.attackedBy[Them][PAWN] & s)
             score -= ThreatenedByPawnPenalty[Piece];
 
-        // Otherwise give a bonus if we are a bishop and can pin a piece or
+        // Otherwise give a bonus if we are a bishop and can pin a piece or can
-        // can give a discovered check through an x-ray attack.
+        // give a discovered check through an x-ray attack.
         else if (    Piece == BISHOP
                  && (PseudoAttacks[Piece][pos.king_square(Them)] & s)
                  && !more_than_one(BetweenBB[s][pos.king_square(Them)] & pos.pieces()))
@@ -594,67 +571,54 @@ Value do_evaluate(const Position& pos, Value& margin) {
             && !(pos.pieces(Them, PAWN) & attack_span_mask(Us, s)))
             score += evaluate_outposts<Piece, Us>(pos, ei, s);
 
-        if ((Piece == ROOK || Piece == QUEEN) && relative_rank(Us, s) >= RANK_5)
+        if (  (Piece == ROOK || Piece == QUEEN)
+            && relative_rank(Us, s) >= RANK_5)
         {
-            // Major piece on 7th rank
+            // Major piece on 7th rank and enemy king trapped on 8th
             if (   relative_rank(Us, s) == RANK_7
                 && relative_rank(Us, pos.king_square(Them)) == RANK_8)
-                score += (Piece == ROOK ? RookOn7thBonus : QueenOn7thBonus);
+                score += Piece == ROOK ? RookOn7thBonus : QueenOn7thBonus;
 
-            // Major piece attacking pawns on the same rank
+            // Major piece attacking enemy pawns on the same rank
             Bitboard pawns = pos.pieces(Them, PAWN) & rank_bb(s);
             if (pawns)
-                score += (Piece == ROOK ? RookOnPawnBonus
+                score += popcount<Max15>(pawns) * (Piece == ROOK ? RookOnPawnBonus : QueenOnPawnBonus);
-                                        : QueenOnPawnBonus) * popcount<Max15>(pawns);
-        }
-
-        // Special extra evaluation for bishops
-        if (Piece == BISHOP && pos.is_chess960())
-        {
-            // An important Chess960 pattern: A cornered bishop blocked by
-            // a friendly pawn diagonally in front of it is a very serious
-            // problem, especially when that pawn is also blocked.
-            if (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1))
-            {
-                Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
-                if (pos.piece_on(s + d) == make_piece(Us, PAWN))
-                {
-                    if (!pos.is_empty(s + d + pawn_push(Us)))
-                        score -= 2*TrappedBishopA1H1Penalty;
-                    else if (pos.piece_on(s + 2*d) == make_piece(Us, PAWN))
-                        score -= TrappedBishopA1H1Penalty;
-                    else
-                        score -= TrappedBishopA1H1Penalty / 2;
-                }
-            }
         }
 
         // Special extra evaluation for rooks
         if (Piece == ROOK)
         {
-            // Open and half-open files
+            // Give a bonus for a rook on a open or half-open file
-            f = file_of(s);
+            if (ei.pi->half_open(Us, file_of(s)))
-            if (ei.pi->file_is_half_open(Us, f))
+                score += ei.pi->half_open(Them, file_of(s)) ? RookOpenFileBonus
-            {
+                                                            : RookHalfOpenFileBonus;
-                if (ei.pi->file_is_half_open(Them, f))
+            if (mob > 6 || ei.pi->half_open(Us, file_of(s)))
-                    score += RookOpenFileBonus;
-                else
-                    score += RookHalfOpenFileBonus;
-            }
-
-            if (mob > 6 || ei.pi->file_is_half_open(Us, f))
                 continue;
 
-            ksq = pos.king_square(Us);
+            Square ksq = pos.king_square(Us);
 
             // Penalize rooks which are trapped inside a king. Penalize more if
             // king has lost right to castle.
             if (   ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq)))
                 && rank_of(ksq) == rank_of(s)
                 && relative_rank(Us, ksq) == RANK_1
-                && !ei.pi->has_open_file_on_side(Us, file_of(ksq), file_of(ksq) < FILE_E))
+                && !ei.pi->half_open_on_side(Us, file_of(ksq), file_of(ksq) < FILE_E))
-                score -= make_score(pos.can_castle(Us) ? (TrappedRookPenalty - mob * 16) / 2
+                score -= (TrappedRookPenalty - make_score(mob * 8, 0)) * (pos.can_castle(Us) ? 1 : 2);
-                                                       : (TrappedRookPenalty - mob * 16), 0);
+        }
+
+        // An important Chess960 pattern: A cornered bishop blocked by a friendly
+        // pawn diagonally in front of it is a very serious problem, especially
+        // when that pawn is also blocked.
+        if (   Piece == BISHOP
+            && pos.is_chess960()
+            && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1)))
+        {
+            const enum Piece P = make_piece(Us, PAWN);
+            Square d = pawn_push(Us) + (file_of(s) == FILE_A ? DELTA_E : DELTA_W);
+            if (pos.piece_on(s + d) == P)
+                score -= !pos.is_empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1Penalty * 4
+                        : pos.piece_on(s + d + d) == P        ? TrappedBishopA1H1Penalty * 2
+                                                              : TrappedBishopA1H1Penalty;
         }
     }
 

src/pawns.h

@@ -37,9 +37,10 @@ struct Entry {
   Score pawns_value() const { return value; }
   Bitboard pawn_attacks(Color c) const { return pawnAttacks[c]; }
   Bitboard passed_pawns(Color c) const { return passedPawns[c]; }
-  int file_is_half_open(Color c, File f) const { return halfOpenFiles[c] & (1 << int(f)); }
   int pawns_on_same_color_squares(Color c, Square s) const { return pawnsOnSquares[c][!!(BlackSquares & s)]; }
-  int has_open_file_on_side(Color c, File f, bool left) const {
+  int half_open(Color c, File f) const { return halfOpenFiles[c] & (1 << int(f)); }
+  int half_open_on_side(Color c, File f, bool left) const {
+
     return halfOpenFiles[c] & (left ? ((1 << int(f)) - 1) : ~((1 << int(f+1)) - 1));
   }
 

src/types.h

@@ -268,7 +268,7 @@ inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }
 /// Extracting the signed lower and upper 16 bits it not so trivial because
 /// according to the standard a simple cast to short is implementation defined
 /// and so is a right shift of a signed integer.
-inline Value mg_value(Score s) { return Value(((s + 32768) & ~0xffff) / 0x10000); }
+inline Value mg_value(Score s) { return Value(((s + 0x8000) & ~0xffff) / 0x10000); }
 
 /// On Intel 64 bit we have a small speed regression with the standard conforming
 /// version, so use a faster code in this case that, although not 100% standard