Refactor Position::pinned_pieces() to use templates

[stockfish] / src / evaluate.cpp

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index 4bda8466e1fdaeddc3e346376d4a37f2a038dbae..a7e5f2d5b8ccf333c8daf583c664946d2c816a8b 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -337,20 +338,20 @@ Value evaluate(const Position &pos, EvalInfo &ei, int threadID) {
   for (Color c = WHITE; c <= BLACK; c++)
   {
     // Knights
-    for (int i = 0; i < pos.knight_count(c); i++)
-        evaluate_knight(pos, pos.knight_list(c, i), c, ei);
+    for (int i = 0; i < pos.piece_count(c, KNIGHT); i++)
+        evaluate_knight(pos, pos.piece_list(c, KNIGHT, i), c, ei);
 
     // Bishops
-    for (int i = 0; i < pos.bishop_count(c); i++)
-        evaluate_bishop(pos, pos.bishop_list(c, i), c, ei);
+    for (int i = 0; i < pos.piece_count(c, BISHOP); i++)
+        evaluate_bishop(pos, pos.piece_list(c, BISHOP, i), c, ei);
 
     // Rooks
-    for (int i = 0; i < pos.rook_count(c); i++)
-        evaluate_rook(pos, pos.rook_list(c, i), c, ei);
+    for (int i = 0; i < pos.piece_count(c, ROOK); i++)
+        evaluate_rook(pos, pos.piece_list(c, ROOK, i), c, ei);
 
     // Queens
-    for(int i = 0; i < pos.queen_count(c); i++)
-        evaluate_queen(pos, pos.queen_list(c, i), c, ei);
+    for(int i = 0; i < pos.piece_count(c, QUEEN); i++)
+        evaluate_queen(pos, pos.piece_list(c, QUEEN, i), c, ei);
 
     // Special pattern: trapped bishops on a7/h7/a2/h2
     Bitboard b = pos.bishops(c) & MaskA7H7[c];
@@ -427,7 +428,7 @@ Value evaluate(const Position &pos, EvalInfo &ei, int threadID) {
       {
           // Check for KBP vs KB with only a single pawn that is almost
           // certainly a draw or at least two pawns.
-          bool one_pawn = (pos.pawn_count(WHITE) + pos.pawn_count(BLACK) == 1);
+          bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
           sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
       }
       else
@@ -569,7 +570,7 @@ namespace {
     if (v && (p.pawn_attacks(them, s) & p.pawns(us)))
     {
         bonus += v / 2;
-        if (   p.knight_count(them) == 0
+        if (   p.piece_count(them, KNIGHT) == 0
             && (SquaresByColorBB[square_color(s)] & p.bishops(them)) == EmptyBoardBB)
             bonus += v;
     }
@@ -724,7 +725,7 @@ namespace {
     // from optimally tuned.
     Color them = opposite_color(us);
 
-    if (   p.queen_count(them) >= 1
+    if (   p.piece_count(them, QUEEN) >= 1
         && ei.kingAttackersCount[them] >= 2
         && p.non_pawn_material(them) >= QueenValueMidgame + RookValueMidgame
         && ei.kingAdjacentZoneAttacksCount[them])
@@ -777,17 +778,17 @@ namespace {
             while (b)
             {
                 Square from, to = pop_1st_bit(&b);
-                if (!(escapeSquares & ~queen_attacks_bb(to, occ & clear_mask_bb(s))))
+                if (!(escapeSquares & ~queen_attacks_bb(to, occ & ClearMaskBB[s])))
                 {
                     // We have a mate, unless the queen is pinned or there
                     // is an X-ray attack through the queen.
-                    for (int i = 0; i < p.queen_count(them); i++)
+                    for (int i = 0; i < p.piece_count(them, QUEEN); i++)
                     {
-                        from = p.queen_list(them, i);
+                        from = p.piece_list(them, QUEEN, i);
                         if (    bit_is_set(p.piece_attacks<QUEEN>(from), to)
                             && !bit_is_set(p.pinned_pieces(them), from)
-                            && !(rook_attacks_bb(to, occ & clear_mask_bb(from)) & p.rooks_and_queens(us))
-                            && !(rook_attacks_bb(to, occ & clear_mask_bb(from)) & p.rooks_and_queens(us)))
+                            && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us))
+                            && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us)))
                             
                             ei.mateThreat[them] = make_move(from, to);
                     }
@@ -994,7 +995,7 @@ namespace {
         // value if the other side has a rook or queen.
         if(square_file(s) == FILE_A || square_file(s) == FILE_H) {
           if(pos.non_pawn_material(them) == KnightValueMidgame
-             && pos.knight_count(them) == 1)
+             && pos.piece_count(them, KNIGHT) == 1)
             ebonus += ebonus / 4;
           else if(pos.rooks_and_queens(them))
             ebonus -= ebonus / 4;