Stockfish 1.3.1

Mainteinance version to fix broken Glaurung 2
book reading.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

polyglot.ini

@@ -2,13 +2,13 @@
 [PolyGlot]
 
 EngineDir = .
-EngineCommand = ./glaurung
+EngineCommand = ./stockfish
 
 Book = false
 BookFile = book.bin
 
 Log = true
-LogFile = glaurung.log
+LogFile = stockfish.log
 
 Resign = true
 ResignScore = 600
@@ -34,8 +34,7 @@ King Safety Coefficient = 40
 King Safety X Intercept = 0
 King Safety Max Slope = 30
 King Safety Max Value = 500
-Queen Contact Check Bonus = 4
+Queen Contact Check Bonus = 3
-Rook Contact Check Bonus = 2
 Queen Check Bonus = 2
 Rook Check Bonus = 1
 Bishop Check Bonus = 1
@@ -57,14 +56,8 @@ Pawn Endgame Extension (non-PV nodes) = 2
 Full Depth Moves (PV nodes) = 14
 Full Depth Moves (non-PV nodes) = 3
 Threat Depth = 5
-Selective Plies = 7
 Futility Pruning (Main Search) = true
 Futility Pruning (Quiescence Search) = true
-Futility Margin 0 = 50
-Futility Margin 1 = 100
-Futility Margin 2 = 300
-Maximum Razoring Depth = 3
-Razoring Margin = 300
 Randomness = 0
 Minimum Split Depth = 4
 Maximum Number of Threads per Split Point = 5

src/Makefile

@@ -24,9 +24,9 @@
 
 EXE = stockfish
 
-OBJS = bitboard.o color.o pawns.o material.o endgame.o evaluate.o main.o \
+OBJS = bitboard.o pawns.o material.o endgame.o evaluate.o main.o \
 	misc.o move.o movegen.o history.o movepick.o search.o piece.o \
-	position.o square.o direction.o tt.o value.o uci.o ucioption.o \
+	position.o direction.o tt.o value.o uci.o ucioption.o \
 	mersenne.o book.o bitbase.o san.o benchmark.o
 
 
@@ -37,7 +37,7 @@ OBJS = bitboard.o color.o pawns.o material.o endgame.o evaluate.o main.o \
 all: $(EXE) .depend
 
 clean:
-	$(RM) *.o .depend glaurung
+	$(RM) *.o .depend stockfish
 
 
 ###
@@ -94,7 +94,7 @@ CXXFLAGS += -wd383,869,981
 # Profiler guided optimization with the Intel C++ compiler.  To use it, first
 # create the directory ./profdata if it does not already exist, and delete its
 # contents if it does exist.  Then compile with -prof_gen, and run the
-# resulting binary for a while (for instance, do ./glaurung bench 128 1, and
+# resulting binary for a while (for instance, do ./stockfish bench 128 1, and
 # wait 15 minutes for the benchmark to complete).  Then do a 'make clean', and
 # recompile with -prof_use.
 

src/benchmark.cpp

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -53,7 +53,7 @@ const std::string BenchmarkPositions[] = {
   "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b  - 3 22",
   "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26"
 };
-  
+
 
 ////
 //// Functions
@@ -71,8 +71,8 @@ void benchmark(const std::string& commandLine) {
 
   std::istringstream csVal(commandLine);
   std::istringstream csStr(commandLine);
-  std::string ttSize, threads, fileName;
+  std::string ttSize, threads, fileName, limitType;
-  int val, secsPerPos;
+  int val, secsPerPos, maxDepth, maxNodes;
 
   csStr >> ttSize;
   csVal >> val;
@@ -88,18 +88,28 @@ void benchmark(const std::string& commandLine) {
       std::cerr << "The number of threads must be between 1 and " << THREAD_MAX
                 << std::endl;
       exit(EXIT_FAILURE);
-  }  
+  }
   set_option_value("Hash", ttSize);
   set_option_value("Threads", threads);
   set_option_value("OwnBook", "false");
   set_option_value("Use Search Log", "true");
   set_option_value("Search Log Filename", "bench.txt");
 
-  csVal >> secsPerPos;
+  csVal >> val;
   csVal >> fileName;
+  csVal >> limitType;
+
+  secsPerPos = maxDepth = maxNodes = 0;
+
+  if (limitType == "time")
+      secsPerPos = val * 1000;
+  else if (limitType == "depth")
+      maxDepth = val;
+  else
+      maxNodes = val;
 
   std::vector<std::string> positions;
-  
+
   if (fileName != "default")
   {
       std::ifstream fenFile(fileName.c_str());
@@ -108,7 +118,7 @@ void benchmark(const std::string& commandLine) {
           std::cerr << "Unable to open positions file " << fileName
                     << std::endl;
           exit(EXIT_FAILURE);
-      }        
+      }
       std::string pos;
       while (fenFile.good())
       {
@@ -121,12 +131,21 @@ void benchmark(const std::string& commandLine) {
       for (int i = 0; i < 16; i++)
           positions.push_back(std::string(BenchmarkPositions[i]));
 
+  int startTime = get_system_time();
   std::vector<std::string>::iterator it;
-  for (it = positions.begin(); it != positions.end(); ++it)
+  int cnt = 1;
+  int64_t totalNodes = 0;
+  for (it = positions.begin(); it != positions.end(); ++it, ++cnt)
   {
-      Move moves[1] = {MOVE_NONE};
+      Move moves[1] = {MOVE_NONE};
-      int dummy[2] = {0, 0};
+      int dummy[2] = {0, 0};
       Position pos(*it);
-      think(pos, true, false, 0, dummy, dummy, 0, 0, 0, secsPerPos * 1000, moves);
+      std::cout << "\nProcessing position " << cnt << '/' << positions.size() << std::endl << std::endl;
+      think(pos, true, false, 0, dummy, dummy, 0, maxDepth, maxNodes, secsPerPos, moves);
+      totalNodes += nodes_searched();
   }
+  std::cout << "\nProcessing time (ms) " << get_system_time() - startTime << std::endl
+            << "Nodes searched " << totalNodes << std::endl
+            << "Press any key to exit" << std::endl;
+  std::cin >> fileName;
 }

src/benchmark.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

src/bitbase.cpp

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -53,11 +53,11 @@ namespace {
     Bitboard wk_attacks() const;
     Bitboard bk_attacks() const;
     Bitboard pawn_attacks() const;
-    
+
     Square whiteKingSquare, blackKingSquare, pawnSquare;
     Color sideToMove;
   };
-    
+
 
   Result *Bitbase;
   const int IndexMax = 2*24*64*64;
@@ -69,7 +69,7 @@ namespace {
   Result classify_btm(const KPKPosition &p);
   int compute_index(Square wksq, Square bksq, Square psq, Color stm);
   int compress_result(Result r);
-  
+
 }
 
 
@@ -89,7 +89,8 @@ void generate_kpk_bitbase(uint8_t bitbase[]) {
   int i, j, b;
   for(i = 0; i < 24576; i++) {
     for(b = 0, j = 0; j < 8; b |= (compress_result(Bitbase[8*i+j]) << j), j++);
-    bitbase[i] = b;
+    assert(b == int(uint8_t(b)));
+    bitbase[i] = (uint8_t)b;
   }
 
   // Release allocated memory:
@@ -113,7 +114,7 @@ namespace {
     return compute_index(whiteKingSquare, blackKingSquare, pawnSquare,
                          sideToMove);
   }
-    
+
 
   bool KPKPosition::is_legal() const {
     if(whiteKingSquare == pawnSquare || whiteKingSquare == blackKingSquare ||
@@ -137,7 +138,7 @@ namespace {
     if(sideToMove == BLACK) {
       Bitboard wka = this->wk_attacks();
       Bitboard bka = this->bk_attacks();
-    
+
       // Case 1: Stalemate
       if((bka & ~(wka | this->pawn_attacks())) == EmptyBoardBB)
         return true;
@@ -166,7 +167,7 @@ namespace {
       (square_distance(blackKingSquare, pawnSquare+DELTA_N) > 1 ||
        bit_is_set(this->wk_attacks(), pawnSquare+DELTA_N));
   }
-    
+
 
   Bitboard KPKPosition::wk_attacks() const {
     return StepAttackBB[WK][whiteKingSquare];
@@ -204,7 +205,7 @@ namespace {
   bool next_iteration() {
     KPKPosition p;
     int previousUnknownCount = UnknownCount;
-    
+
     for(int i = 0; i < IndexMax; i++)
       if(Bitbase[i] == RESULT_UNKNOWN) {
         p.from_index(i);
@@ -231,7 +232,7 @@ namespace {
     bool unknownFound = false;
     Bitboard b;
     Square s;
-    
+
     // King moves
     b = p.wk_attacks();
     while(b) {
@@ -260,14 +261,14 @@ namespace {
                                    BLACK)]) {
       case RESULT_LOSS:
         return RESULT_WIN;
-        
+
       case RESULT_UNKNOWN:
         unknownFound = true;
         break;
-          
+
       case RESULT_DRAW: case RESULT_INVALID:
         break;
-        
+
       default:
         assert(false);
       }
@@ -279,20 +280,20 @@ namespace {
                                      BLACK)]) {
         case RESULT_LOSS:
           return RESULT_WIN;
-          
+
         case RESULT_UNKNOWN:
           unknownFound = true;
           break;
-          
+
         case RESULT_DRAW: case RESULT_INVALID:
           break;
-          
+
         default:
           assert(false);
         }
       }
     }
-    
+
     return unknownFound? RESULT_UNKNOWN : RESULT_DRAW;
   }
 
@@ -345,5 +346,5 @@ namespace {
   int compress_result(Result r) {
     return (r == RESULT_WIN || r == RESULT_LOSS)? 1 : 0;
   }
-      
+
-}  
+}

src/bitbase.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

src/bitboard.cpp

@@ -38,64 +38,6 @@
 #include "direction.h"
 
 
-////
-//// Constants and variables
-////
-
-const Bitboard SquaresByColorBB[2] = {BlackSquaresBB, WhiteSquaresBB};
-
-const Bitboard FileBB[8] = {
-  FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB
-};
-
-const Bitboard NeighboringFilesBB[8] = {
-  FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB,
-  FileDBB|FileFBB, FileEBB|FileGBB, FileFBB|FileHBB, FileGBB
-};
-
-const Bitboard ThisAndNeighboringFilesBB[8] = {
-  FileABB|FileBBB, FileABB|FileBBB|FileCBB,
-  FileBBB|FileCBB|FileDBB, FileCBB|FileDBB|FileEBB,
-  FileDBB|FileEBB|FileFBB, FileEBB|FileFBB|FileGBB,
-  FileFBB|FileGBB|FileHBB, FileGBB|FileHBB
-};
-
-const Bitboard RankBB[8] = {
-  Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
-};
-
-const Bitboard RelativeRankBB[2][8] = {
-  {
-    Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
-  },
-  {
-    Rank8BB, Rank7BB, Rank6BB, Rank5BB, Rank4BB, Rank3BB, Rank2BB, Rank1BB
-  }
-};
-
-const Bitboard InFrontBB[2][8] = {
-  {
-    Rank2BB | Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank6BB | Rank7BB | Rank8BB,
-    Rank7BB | Rank8BB,
-    Rank8BB,
-    EmptyBoardBB
-  },
-  {
-    EmptyBoardBB,
-    Rank1BB,
-    Rank2BB | Rank1BB,
-    Rank3BB | Rank2BB | Rank1BB,
-    Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank7BB | Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB
-  }
-};
-
 #if defined(USE_COMPACT_ROOK_ATTACKS)
 
 Bitboard RankAttacks[8][64], FileAttacks[8][64];
@@ -250,8 +192,8 @@ Bitboard BMask[64];
 int BAttackIndex[64];
 Bitboard BAttacks[0x1480];
 
-Bitboard SetMaskBB[64];
+Bitboard SetMaskBB[65];
-Bitboard ClearMaskBB[64];
+Bitboard ClearMaskBB[65];
 
 Bitboard StepAttackBB[16][64];
 Bitboard RayBB[64][8];
@@ -270,6 +212,7 @@ Bitboard QueenPseudoAttacks[64];
 ////
 
 namespace {
+
   void init_masks();
   void init_ray_bitboards();
   void init_attacks();
@@ -433,6 +376,8 @@ namespace {
   // be necessary to touch any of them.
 
   void init_masks() {
+    SetMaskBB[SQ_NONE] = 0ULL;
+    ClearMaskBB[SQ_NONE] = ~SetMaskBB[SQ_NONE];
     for(Square s = SQ_A1; s <= SQ_H8; s++) {
       SetMaskBB[s] = (1ULL << s);
       ClearMaskBB[s] = ~SetMaskBB[s];
@@ -448,7 +393,7 @@ namespace {
 
   void init_ray_bitboards() {
     int d[8] = {1, -1, 16, -16, 17, -17, 15, -15};
-    for(int i = 0; i < 128; i = i + 9 & ~8) {
+    for(int i = 0; i < 128; i = (i + 9) & ~8) {
       for(int j = 0; j < 8; j++) {
         RayBB[(i&7)|((i>>4)<<3)][j] = EmptyBoardBB;
         for(int k = i + d[j]; (k & 0x88) == 0; k += d[j])
@@ -534,8 +479,15 @@ namespace {
     for(i = 0; i < 64; i++) {
       attackIndex[i] = index;
       mask[i] = sliding_attacks(i, 0ULL, 4, deltas, 1, 6, 1, 6);
+
+#if defined(USE_32BIT_ATTACKS)
+      j = (1 << (32 - shift[i]));
+#else
       j = (1 << (64 - shift[i]));
+#endif
+
       for(k = 0; k < j; k++) {
+
 #if defined(USE_32BIT_ATTACKS)
         b = index_to_bitboard(k, mask[i]);
         attacks[index +

src/bitboard.h

@@ -84,8 +84,7 @@ const Bitboard EmptyBoardBB = 0ULL;
 
 const Bitboard WhiteSquaresBB = 0x55AA55AA55AA55AAULL;
 const Bitboard BlackSquaresBB = 0xAA55AA55AA55AA55ULL;
-
+const Bitboard SquaresByColorBB[2] = { BlackSquaresBB, WhiteSquaresBB };
-extern const Bitboard SquaresByColorBB[2];
 
 const Bitboard FileABB = 0x0101010101010101ULL;
 const Bitboard FileBBB = 0x0202020202020202ULL;
@@ -96,9 +95,21 @@ const Bitboard FileFBB = 0x2020202020202020ULL;
 const Bitboard FileGBB = 0x4040404040404040ULL;
 const Bitboard FileHBB = 0x8080808080808080ULL;
 
-extern const Bitboard FileBB[8];
+const Bitboard FileBB[8] = {
-extern const Bitboard NeighboringFilesBB[8];
+  FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB
-extern const Bitboard ThisAndNeighboringFilesBB[8];
+};
+
+const Bitboard NeighboringFilesBB[8] = {
+  FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB,
+  FileDBB|FileFBB, FileEBB|FileGBB, FileFBB|FileHBB, FileGBB
+};
+
+const Bitboard ThisAndNeighboringFilesBB[8] = {
+  FileABB|FileBBB, FileABB|FileBBB|FileCBB,
+  FileBBB|FileCBB|FileDBB, FileCBB|FileDBB|FileEBB,
+  FileDBB|FileEBB|FileFBB, FileEBB|FileFBB|FileGBB,
+  FileFBB|FileGBB|FileHBB, FileGBB|FileHBB
+};
 
 const Bitboard Rank1BB = 0xFFULL;
 const Bitboard Rank2BB = 0xFF00ULL;
@@ -109,12 +120,38 @@ const Bitboard Rank6BB = 0xFF0000000000ULL;
 const Bitboard Rank7BB = 0xFF000000000000ULL;
 const Bitboard Rank8BB = 0xFF00000000000000ULL;
 
-extern const Bitboard RankBB[8];
+const Bitboard RankBB[8] = {
-extern const Bitboard RelativeRankBB[2][8];
+  Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
-extern const Bitboard InFrontBB[2][8];
+};
 
-extern Bitboard SetMaskBB[64];
+const Bitboard RelativeRankBB[2][8] = {
-extern Bitboard ClearMaskBB[64];
+  { Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB },
+  { Rank8BB, Rank7BB, Rank6BB, Rank5BB, Rank4BB, Rank3BB, Rank2BB, Rank1BB }
+};
+
+const Bitboard InFrontBB[2][8] = {
+  { Rank2BB | Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank6BB | Rank7BB | Rank8BB,
+    Rank7BB | Rank8BB,
+    Rank8BB,
+    EmptyBoardBB
+  },
+  { EmptyBoardBB,
+    Rank1BB,
+    Rank2BB | Rank1BB,
+    Rank3BB | Rank2BB | Rank1BB,
+    Rank4BB | Rank3BB | Rank2BB | Rank1BB,
+    Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
+    Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
+    Rank7BB | Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB
+  }
+};
+
+extern Bitboard SetMaskBB[65];
+extern Bitboard ClearMaskBB[65];
 
 extern Bitboard StepAttackBB[16][64];
 extern Bitboard RayBB[64][8];
@@ -124,13 +161,17 @@ extern Bitboard PassedPawnMask[2][64];
 extern Bitboard OutpostMask[2][64];
 
 #if defined(USE_COMPACT_ROOK_ATTACKS)
+
 extern Bitboard RankAttacks[8][64], FileAttacks[8][64];
+
 #else
+
 extern const uint64_t RMult[64];
 extern const int RShift[64];
 extern Bitboard RMask[64];
 extern int RAttackIndex[64];
 extern Bitboard RAttacks[0x19000];
+
 #endif // defined(USE_COMPACT_ROOK_ATTACKS)
 
 extern const uint64_t BMult[64];
@@ -212,7 +253,7 @@ inline Bitboard this_and_neighboring_files_bb(Square s) {
 
 /// relative_rank_bb() takes a color and a rank as input, and returns a bitboard
 /// representing all squares on the given rank from the given color's point of
-/// view.  For instance, relative_rank_bb(WHITE, 7) gives all squares on the
+/// view. For instance, relative_rank_bb(WHITE, 7) gives all squares on the
 /// 7th rank, while relative_rank_bb(BLACK, 7) gives all squares on the 2nd
 /// rank.
 
@@ -236,6 +277,19 @@ inline Bitboard in_front_bb(Color c, Square s) {
 }
 
 
+/// behind_bb() takes a color and a rank or square as input, and returns a
+/// bitboard representing all the squares on all ranks behind of the rank
+/// (or square), from the given color's point of view.
+
+inline Bitboard behind_bb(Color c, Rank r) {
+  return InFrontBB[opposite_color(c)][r];
+}
+
+inline Bitboard behind_bb(Color c, Square s) {
+  return in_front_bb(opposite_color(c), square_rank(s));
+}
+
+
 /// ray_bb() gives a bitboard representing all squares along the ray in a
 /// given direction from a given square.
 
@@ -382,24 +436,25 @@ inline int count_1s_max_15(Bitboard b) {
 
 inline int count_1s(Bitboard b) {
   unsigned w = unsigned(b >> 32), v = unsigned(b);
-  v = v - ((v >> 1) & 0x55555555);
+  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
-  w = w - ((w >> 1) & 0x55555555);
+  w -= (w >> 1) & 0x55555555;
-  v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
+  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
-  w = (w & 0x33333333) + ((w >> 2) & 0x33333333);
+  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
-  v = (v + (v >> 4)) & 0x0F0F0F0F;
+  v = ((v >> 4) + v) & 0x0F0F0F0F; // 0-8 in 8 bits
-  w = (w + (w >> 4)) & 0x0F0F0F0F;
+  v += (((w >> 4) + w) & 0x0F0F0F0F);  // 0-16 in 8 bits
-  v = ((v+w) * 0x01010101) >> 24; // mul is fast on amd procs
+  v *= 0x01010101; // mul is fast on amd procs
-  return int(v);
+  return int(v >> 24);
 }
 
 inline int count_1s_max_15(Bitboard b) {
   unsigned w = unsigned(b >> 32), v = unsigned(b);
-  v = v - ((v >> 1) & 0x55555555);
+  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
-  w = w - ((w >> 1) & 0x55555555);
+  w -= (w >> 1) & 0x55555555;
-  v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
+  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
-  w = (w & 0x33333333) + ((w >> 2) & 0x33333333);
+  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
-  v = ((v+w) * 0x11111111) >> 28;
+  v += w; // 0-8 in 4 bits
-  return int(v);
+  v *= 0x11111111;
+  return int(v >> 28);
 }
 
 #elif defined(BITCOUNT_SWAR_64)

src/book.cpp

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -317,22 +317,22 @@ namespace {
 
 
   /// Indices to the Random64[] array
-  
+
   const int RandomPiece = 0;
   const int RandomCastle = 768;
   const int RandomEnPassant = 772;
   const int RandomTurn = 780;
 
-  
+
   /// Convert pieces to the range 0..1
-  
+
   const int PieceTo12[] = {
     0, 0, 2, 4, 6, 8, 10, 0, 0, 1, 3, 5, 7, 9, 11
   };
 
 
   /// Prototypes
-  
+
   uint64_t book_key(const Position &pos);
   uint64_t book_piece_key(Piece p, Square s);
   uint64_t book_castle_key(const Position &pos);
@@ -364,7 +364,7 @@ void Book::open(const std::string &fName) {
   if (!bookFile.is_open())
       return;
 
-  bookFile.seekg(0, std::ios::end);
+  bookFile.seekg(0, std::ios::end);
   bookSize = bookFile.tellg() / 16;
   bookFile.seekg(0, std::ios::beg);
 
@@ -388,7 +388,7 @@ void Book::close() {
 /// Book::is_open() tests whether a book file has been opened.
 
 bool Book::is_open() const {
-  
+
   return bookFile.is_open() && bookSize != 0;
 }
 
@@ -400,7 +400,7 @@ const std::string Book::file_name() const {
 
   return bookFile.is_open() ? fileName : "";
 }
-  
+
 
 /// Book::get_move() gets a book move for a given position.  Returns
 /// MOVE_NONE if no book move is found.
@@ -524,7 +524,7 @@ namespace {
 
     return result;
   }
-        
+
 
   uint64_t book_piece_key(Piece p, Square s) {
     return Random64[RandomPiece + (PieceTo12[int(p)]^1)*64 + int(s)];
@@ -545,29 +545,29 @@ namespace {
     return result;
   }
 
-  
+
   uint64_t book_ep_key(const Position &pos) {
     return (pos.ep_square() == SQ_NONE)?
       0ULL : Random64[RandomEnPassant + square_file(pos.ep_square())];
   }
 
-  
+
   uint64_t book_color_key(const Position &pos) {
     return (pos.side_to_move() == WHITE)? Random64[RandomTurn] : 0ULL;
   }
-  
+
 
   uint16_t read_integer16(std::ifstream& file) {
-    
+
     uint64_t n = read_integer(file, 2);
     assert(n == (uint16_t)n);
-    return (uint16_t)n;      
+    return (uint16_t)n;
   }
 
 
   uint64_t read_integer64(std::ifstream& file) {
-    
+
-    return read_integer(file, 8);      
+    return read_integer(file, 8);
   }
 
 

src/book.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

src/color.cpp

@@ -1,36 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
-
-  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.
-  
-  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.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include "color.h"
-
-
-////
-//// Functions
-////
-
-/// color_is_ok(), for debugging:
-
-bool color_is_ok(Color c) {
-  return c == WHITE || c == BLACK;
-}

src/color.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -21,20 +21,14 @@
 #if !defined(COLOR_H_INCLUDED)
 #define COLOR_H_INCLUDED
 
-////
-//// Includes
-////
-
-#include "misc.h"
-
 
 ////
 //// Types
 ////
 
 enum Color {
-  WHITE, 
+  WHITE,
-  BLACK, 
+  BLACK,
   COLOR_NONE
 };
 
@@ -44,18 +38,14 @@ enum Color {
 ////
 
 inline Color operator+ (Color c, int i) { return Color(int(c) + i); }
-inline void operator++ (Color &c, int i) { c = Color(int(c) + 1); }
+inline void operator++ (Color &c, int) { c = Color(int(c) + 1); }
 
 inline Color opposite_color(Color c) {
   return Color(int(c) ^ 1);
 }
 
-
+inline bool color_is_ok(Color c) {
-////
+  return c == WHITE || c == BLACK;
-//// Prototypes
+}
-////
-
-extern bool color_is_ok(Color c);
-
 
 #endif // !defined(COLOR_H_INCLUDED)

src/depth.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

src/direction.cpp

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

src/direction.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -38,8 +38,8 @@ enum Direction {
 };
 
 enum SignedDirection {
-  SIGNED_DIR_E = 0, SIGNED_DIR_W = 1,
+  SIGNED_DIR_E  = 0, SIGNED_DIR_W  = 1,
-  SIGNED_DIR_N = 2, SIGNED_DIR_S = 3,
+  SIGNED_DIR_N  = 2, SIGNED_DIR_S  = 3,
   SIGNED_DIR_NE = 4, SIGNED_DIR_SW = 5,
   SIGNED_DIR_NW = 6, SIGNED_DIR_SE = 7,
   SIGNED_DIR_NONE = 8
@@ -58,9 +58,11 @@ extern uint8_t SignedDirectionTable[64][64];
 //// Inline functions
 ////
 
-inline void operator++ (Direction &d, int) { d = Direction(int(d) + 1); }
+inline void operator++ (Direction& d, int) {
+  d = Direction(int(d) + 1);
+}
 
-inline void operator++ (SignedDirection &d, int) {
+inline void operator++ (SignedDirection& d, int) {
   d = SignedDirection(int(d) + 1);
 }
 
@@ -72,6 +74,13 @@ inline SignedDirection signed_direction_between_squares(Square s1, Square s2) {
   return SignedDirection(SignedDirectionTable[s1][s2]);
 }
 
+inline int direction_is_diagonal(Square s1, Square s2) {
+  return DirectionTable[s1][s2] & 2;
+}
+
+inline bool direction_is_straight(Square s1, Square s2) {
+  return DirectionTable[s1][s2] < 2;
+}
 
 ////
 //// Prototypes

src/endgame.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -34,149 +34,61 @@
 //// Types
 ////
 
-/// Abstract base class for all special endgame evaluation functions:
+enum EndgameType {
 
-class EndgameEvaluationFunction {
+    // Evaluation functions
+    KXK,   // Generic "mate lone king" eval
+    KBNK,  // KBN vs K
+    KPK,   // KP vs K
+    KRKP,  // KR vs KP
+    KRKB,  // KR vs KB
+    KRKN,  // KR vs KN
+    KQKR,  // KQ vs KR
+    KBBKN, // KBB vs KN
+    KmmKm, // K and two minors vs K and one or two minors
+
+    // Scaling functions
+    KBPK,    // KBP vs K
+    KQKRP,   // KQ vs KRP
+    KRPKR,   // KRP vs KR
+    KRPPKRP, // KRPP vs KRP
+    KPsK,    // King and pawns vs king
+    KBPKB,   // KBP vs KB
+    KBPPKB,  // KBPP vs KB
+    KBPKN,   // KBP vs KN
+    KNPK,    // KNP vs K
+    KPKP     // KP vs KP
+};
+
+/// Template abstract base class for all special endgame functions
+
+template<typename T>
+class EndgameFunctionBase {
 public:
-  EndgameEvaluationFunction(Color c);
+  EndgameFunctionBase(Color c) : strongerSide(c) { weakerSide = opposite_color(strongerSide); }
-  virtual ~EndgameEvaluationFunction() { }
+  virtual ~EndgameFunctionBase() {}
-
+  virtual T apply(const Position&) = 0;
-  virtual Value apply(const Position &pos) =0;
 
 protected:
   Color strongerSide, weakerSide;
 };
 
+typedef EndgameFunctionBase<Value> EndgameEvaluationFunctionBase;
+typedef EndgameFunctionBase<ScaleFactor> EndgameScalingFunctionBase;
 
-/// Subclasses for various concrete endgames:
 
-// Generic "mate lone king" eval:
+/// Templates subclass for various concrete endgames
-class KXKEvaluationFunction : public EndgameEvaluationFunction {
+
-public:
+template<EndgameType>
-  KXKEvaluationFunction(Color c);
+struct EvaluationFunction : public EndgameEvaluationFunctionBase {
-  Value apply(const Position &pos);
+  explicit EvaluationFunction(Color c): EndgameEvaluationFunctionBase(c) {}
+  Value apply(const Position&);
 };
 
-// KBN vs K:
+template<EndgameType>
-class KBNKEvaluationFunction : public EndgameEvaluationFunction {
+struct ScalingFunction : public EndgameScalingFunctionBase {
-public:
+  explicit ScalingFunction(Color c) : EndgameScalingFunctionBase(c) {}
-  KBNKEvaluationFunction(Color c);
+  ScaleFactor apply(const Position&);
-  Value apply(const Position &pos);
-};
-
-// KP vs K:
-class KPKEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KPKEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KP:
-class KRKPEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKPEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KB:
-class KRKBEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKBEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KN:
-class KRKNEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKNEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KQ vs KR:
-class KQKREvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KQKREvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-
-/// Abstract base class for all evaluation scaling functions:
-
-class ScalingFunction {
-public:
-  ScalingFunction(Color c);
-  virtual ~ScalingFunction() { }
-
-  virtual ScaleFactor apply(const Position &pos) =0;
-
-protected:
-  Color strongerSide, weakerSide;
-};
-
-
-/// Subclasses for various concrete endgames:
-
-// KBP vs K:
-class KBPKScalingFunction : public ScalingFunction {
-public:
-  KBPKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KQ vs KRP:
-class KQKRPScalingFunction: public ScalingFunction {
-public:
-  KQKRPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KRP vs KR:
-class KRPKRScalingFunction : public ScalingFunction {
-public:
-  KRPKRScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KRPP vs KRP:
-class KRPPKRPScalingFunction : public ScalingFunction {
-public:
-  KRPPKRPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// King and pawns vs king:
-class KPsKScalingFunction : public ScalingFunction {
-public:
-  KPsKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KBP vs KB:
-class KBPKBScalingFunction : public ScalingFunction {
-public:
-  KBPKBScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KBP vs KN:
-class KBPKNScalingFunction : public ScalingFunction {
-public:
-  KBPKNScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KNP vs K:
-class KNPKScalingFunction : public ScalingFunction {
-public:
-  KNPKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KP vs KP:
-class KPKPScalingFunction : public ScalingFunction {
-public:
-  KPKPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
 };
 
 
@@ -184,54 +96,26 @@ public:
 //// Constants and variables
 ////
 
-// Generic "mate lone king" eval:
+extern EvaluationFunction<KXK> EvaluateKXK, EvaluateKKX;       // Generic "mate lone king" eval
-extern KXKEvaluationFunction EvaluateKXK, EvaluateKKX;
+extern EvaluationFunction<KBNK> EvaluateKBNK, EvaluateKKBN;    // KBN vs K
-
+extern EvaluationFunction<KPK> EvaluateKPK, EvaluateKKP;       // KP vs K
-// KBN vs K:
+extern EvaluationFunction<KRKP> EvaluateKRKP, EvaluateKPKR;    // KR vs KP
-extern KBNKEvaluationFunction EvaluateKBNK, EvaluateKKBN;
+extern EvaluationFunction<KRKB> EvaluateKRKB, EvaluateKBKR;    // KR vs KB
-
+extern EvaluationFunction<KRKN> EvaluateKRKN, EvaluateKNKR;    // KR vs KN
-// KP vs K:
+extern EvaluationFunction<KQKR> EvaluateKQKR, EvaluateKRKQ;    // KQ vs KR
-extern KPKEvaluationFunction EvaluateKPK, EvaluateKKP;
+extern EvaluationFunction<KBBKN> EvaluateKBBKN, EvaluateKNKBB; // KBB vs KN
-
+extern EvaluationFunction<KmmKm> EvaluateKmmKm; // K and two minors vs K and one or two minors:
-// KR vs KP:
-extern KRKPEvaluationFunction EvaluateKRKP, EvaluateKPKR;
-
-// KR vs KB:
-extern KRKBEvaluationFunction EvaluateKRKB, EvaluateKBKR;
-
-// KR vs KN:
-extern KRKNEvaluationFunction EvaluateKRKN, EvaluateKNKR;
-
-// KQ vs KR:
-extern KQKREvaluationFunction EvaluateKQKR, EvaluateKRKQ;
-
-// KBP vs K:
-extern KBPKScalingFunction ScaleKBPK, ScaleKKBP;
-
-// KQ vs KRP:
-extern KQKRPScalingFunction ScaleKQKRP, ScaleKRPKQ;
-
-// KRP vs KR:
-extern KRPKRScalingFunction ScaleKRPKR, ScaleKRKRP;
-
-// KRPP vs KRP:
-extern KRPPKRPScalingFunction ScaleKRPPKRP, ScaleKRPKRPP;
-
-// King and pawns vs king:
-extern KPsKScalingFunction ScaleKPsK, ScaleKKPs;
-
-// KBP vs KB:
-extern KBPKBScalingFunction ScaleKBPKB, ScaleKBKBP;
-
-// KBP vs KN:
-extern KBPKNScalingFunction ScaleKBPKN, ScaleKNKBP;
-
-// KNP vs K:
-extern KNPKScalingFunction ScaleKNPK, ScaleKKNP;
-
-// KP vs KP:
-extern KPKPScalingFunction ScaleKPKPw, ScaleKPKPb;
 
+extern ScalingFunction<KBPK> ScaleKBPK, ScaleKKBP;    // KBP vs K
+extern ScalingFunction<KQKRP> ScaleKQKRP, ScaleKRPKQ; // KQ vs KRP
+extern ScalingFunction<KRPKR> ScaleKRPKR, ScaleKRKRP; // KRP vs KR
+extern ScalingFunction<KRPPKRP> ScaleKRPPKRP, ScaleKRPKRPP; // KRPP vs KRP
+extern ScalingFunction<KPsK> ScaleKPsK, ScaleKKPs;    // King and pawns vs king
+extern ScalingFunction<KBPKB> ScaleKBPKB, ScaleKBKBP; // KBP vs KB
+extern ScalingFunction<KBPPKB> ScaleKBPPKB, ScaleKBKBPP; // KBPP vs KB
+extern ScalingFunction<KBPKN> ScaleKBPKN, ScaleKNKBP; // KBP vs KN
+extern ScalingFunction<KNPK> ScaleKNPK, ScaleKKNP;    // KNP vs K
+extern ScalingFunction<KPKP> ScaleKPKPw, ScaleKPKPb;  // KP vs KP
 
 ////
 //// Prototypes

src/evaluate.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -27,29 +27,30 @@
 
 #include "material.h"
 #include "pawns.h"
-#include "position.h"
 
 
 ////
 //// Types
 ////
 
+
 /// The EvalInfo struct contains various information computed and collected
-/// by the evaluation function.  An EvalInfo object is passed as one of the
+/// by the evaluation function. An EvalInfo object is passed as one of the
 /// arguments to the evaluation function, and the search can make use of its
 /// contents to make intelligent search decisions.
 ///
 /// At the moment, this is not utilized very much:  The only part of the
 /// EvalInfo object which is used by the search is futilityMargin.
+class Position;
 
 struct EvalInfo {
-  
+
-  // Middle game and endgame evaluations:
+  // Middle game and endgame evaluations
   Value mgValue, egValue;
 
-  // Pointers to material and pawn hash table entries:
+  // Pointers to material and pawn hash table entries
-  MaterialInfo *mi;
+  MaterialInfo* mi;
-  PawnInfo *pi;
+  PawnInfo* pi;
 
   // attackedBy[color][piece type] is a bitboard representing all squares
   // attacked by a given color and piece type.  attackedBy[color][0] contains
@@ -91,7 +92,7 @@ struct EvalInfo {
   Value mgMobility, egMobility;
 
   // Extra futility margin.  This is added to the standard futility margin
-  // in the quiescence search.  
+  // in the quiescence search.
   Value futilityMargin;
 };
 
@@ -100,8 +101,8 @@ struct EvalInfo {
 //// Prototypes
 ////
 
-extern Value evaluate(const Position &pos, EvalInfo &ei, int threadID);
+extern Value evaluate(const Position& pos, EvalInfo& ei, int threadID);
-extern Value quick_evaluate(const Position &pos);
+extern Value quick_evaluate(const Position& pos);
 extern void init_eval(int threads);
 extern void quit_eval();
 extern void read_weights(Color sideToMove);

src/history.cpp

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -92,7 +92,7 @@ int History::move_ordering_score(Piece p, Move m) const {
 
 
 /// History::ok_to_prune() decides whether a move has been sufficiently
-/// unsuccessful that it makes sense to prune it entirely. 
+/// unsuccessful that it makes sense to prune it entirely.
 
 bool History::ok_to_prune(Piece p, Move m, Depth d) const {
   assert(piece_is_ok(p));

src/history.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

src/lock.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -87,7 +87,7 @@ typedef pthread_mutex_t Lock;
 #else
 
 
-#  include <windows.h>
+#include <windows.h>
 
 typedef CRITICAL_SECTION Lock;
 #  define lock_init(x, y) InitializeCriticalSection(x)

src/main.cpp

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -41,7 +41,7 @@
 
 using std::string;
 
-//// 
+////
 //// Functions
 ////
 
@@ -52,7 +52,6 @@ int main(int argc, char *argv[]) {
   std::cin.rdbuf()->pubsetbuf(NULL, 0);
 
   // Initialization
-
   init_mersenne();
   init_direction_table();
   init_bitboards();
@@ -71,16 +70,18 @@ int main(int argc, char *argv[]) {
   // Process command line arguments
   if (argc >= 2 && string(argv[1]) == "bench")
   {
-      if (argc < 4 || argc > 6)
+      if (argc < 4 || argc > 7)
       {
-        std::cout << "Usage: glaurung bench <hash size> <threads> "
+        std::cout << "Usage: stockfish bench <hash size> <threads> "
-                  << "[time = 60s] [fen positions file = default]"
+                  << "[time = 60s] [fen positions file = default] "
+                  << "[time, depth or node limited = time]"
                   << std::endl;
         exit(0);
       }
       string time = argc > 4 ? argv[4] : "60";
       string fen = argc > 5 ? argv[5] : "default";
-      benchmark(string(argv[2]) + " " + string(argv[3]) + " " + time + " " + fen);
+      string lim = argc > 6 ? argv[6] : "time";
+      benchmark(string(argv[2]) + " " + string(argv[3]) + " " + time + " " + fen + " " + lim);
       return 0;
   }
 

src/material.cpp

@@ -24,6 +24,7 @@
 
 #include <cassert>
 #include <cstring>
+#include <sstream>
 #include <map>
 
 #include "material.h"
@@ -35,8 +36,8 @@
 
 namespace {
 
-  const Value BishopPairMidgameBonus = Value(100);
+  const Value BishopPairMidgameBonus = Value(109);
-  const Value BishopPairEndgameBonus = Value(100);
+  const Value BishopPairEndgameBonus = Value(97);
 
   Key KNNKMaterialKey, KKNNMaterialKey;
 
@@ -54,20 +55,21 @@ class EndgameFunctions {
 
 public:
   EndgameFunctions();
-  EndgameEvaluationFunction* getEEF(Key key) const;
+  EndgameEvaluationFunctionBase* getEEF(Key key) const;
-  ScalingFunction* getESF(Key key, Color* c) const;
+  EndgameScalingFunctionBase* getESF(Key key, Color* c) const;
 
 private:
-  void add(Key k, EndgameEvaluationFunction* f);
+  void add(const std::string& keyCode, EndgameEvaluationFunctionBase* f);
-  void add(Key k, Color c, ScalingFunction* f);
+  void add(const std::string& keyCode, Color c, EndgameScalingFunctionBase* f);
+  Key buildKey(const std::string& keyCode);
 
   struct ScalingInfo
   {
       Color col;
-      ScalingFunction* fun;
+      EndgameScalingFunctionBase* fun;
   };
 
-  std::map<Key, EndgameEvaluationFunction*> EEFmap;
+  std::map<Key, EndgameEvaluationFunctionBase*> EEFmap;
   std::map<Key, ScalingInfo> ESFmap;
 };
 
@@ -143,7 +145,8 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
   }
 
   // Let's look if we have a specialized evaluation function for this
-  // particular material configuration.
+  // particular material configuration. First we look for a fixed
+  // configuration one, then a generic one if previous search failed.
   if ((mi->evaluationFunction = funcs->getEEF(key)) != NULL)
       return mi;
 
@@ -161,6 +164,22 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
       mi->evaluationFunction = &EvaluateKKX;
       return mi;
   }
+  else if (   pos.pawns() == EmptyBoardBB
+           && pos.rooks() == EmptyBoardBB
+           && pos.queens() == EmptyBoardBB)
+  {
+      // Minor piece endgame with at least one minor piece per side,
+      // and no pawns.
+      assert(pos.knights(WHITE) | pos.bishops(WHITE));
+      assert(pos.knights(BLACK) | pos.bishops(BLACK));
+
+      if (   pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2
+          && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2)
+      {
+          mi->evaluationFunction = &EvaluateKmmKm;
+          return mi;
+      }
+  }
 
   // OK, we didn't find any special evaluation function for the current
   // material configuration. Is there a suitable scaling function?
@@ -170,7 +189,7 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
   // are several conflicting applicable scaling functions and we need to
   // decide which one to use.
   Color c;
-  ScalingFunction* sf;
+  EndgameScalingFunctionBase* sf;
 
   if ((sf = funcs->getESF(key, &c)) != NULL)
   {
@@ -221,6 +240,18 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
       }
   }
 
+  // Compute the space weight
+  if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >=
+      2*QueenValueMidgame + 4*RookValueMidgame + 2*KnightValueMidgame)
+  {
+      int minorPieceCount =  pos.piece_count(WHITE, KNIGHT)
+                           + pos.piece_count(BLACK, KNIGHT)
+                           + pos.piece_count(WHITE, BISHOP)
+                           + pos.piece_count(BLACK, BISHOP);
+
+      mi->spaceWeight = minorPieceCount * minorPieceCount;
+  }
+
   // Evaluate the material balance
 
   int sign;
@@ -281,67 +312,85 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
 
 
 /// EndgameFunctions member definitions. This class is used to store the maps
-/// of end game and scaling functions that MaterialInfoTable will query for 
+/// of end game and scaling functions that MaterialInfoTable will query for
 /// each key. The maps are constant and are populated only at construction,
 /// but are per-thread instead of globals to avoid expensive locks.
 
 EndgameFunctions::EndgameFunctions() {
 
-  typedef Key ZM[2][8][16];
+  KNNKMaterialKey = buildKey("KNNK");
-  const ZM& z = Position::zobMaterial;
+  KKNNMaterialKey = buildKey("KKNN");
 
-  static const Color W = WHITE;
+  add("KPK",   &EvaluateKPK);
-  static const Color B = BLACK;
+  add("KKP",   &EvaluateKKP);
+  add("KBNK",  &EvaluateKBNK);
+  add("KKBN",  &EvaluateKKBN);
+  add("KRKP",  &EvaluateKRKP);
+  add("KPKR",  &EvaluateKPKR);
+  add("KRKB",  &EvaluateKRKB);
+  add("KBKR",  &EvaluateKBKR);
+  add("KRKN",  &EvaluateKRKN);
+  add("KNKR",  &EvaluateKNKR);
+  add("KQKR",  &EvaluateKQKR);
+  add("KRKQ",  &EvaluateKRKQ);
+  add("KBBKN", &EvaluateKBBKN);
+  add("KNKBB", &EvaluateKNKBB);
 
-  KNNKMaterialKey = z[W][KNIGHT][1] ^ z[W][KNIGHT][2];
+  add("KNPK",    WHITE, &ScaleKNPK);
-  KKNNMaterialKey = z[B][KNIGHT][1] ^ z[B][KNIGHT][2];
+  add("KKNP",    BLACK, &ScaleKKNP);
-
+  add("KRPKR",   WHITE, &ScaleKRPKR);
-  add(z[W][PAWN][1], &EvaluateKPK);
+  add("KRKRP",   BLACK, &ScaleKRKRP);
-  add(z[B][PAWN][1], &EvaluateKKP);
+  add("KBPKB",   WHITE, &ScaleKBPKB);
-
+  add("KBKBP",   BLACK, &ScaleKBKBP);
-  add(z[W][BISHOP][1] ^ z[W][KNIGHT][1], &EvaluateKBNK);
+  add("KBPPKB",  WHITE, &ScaleKBPPKB);
-  add(z[B][BISHOP][1] ^ z[B][KNIGHT][1], &EvaluateKKBN);
+  add("KBKBPP",  BLACK, &ScaleKBKBPP);
-  add(z[W][ROOK][1]   ^ z[B][PAWN][1],   &EvaluateKRKP);
+  add("KBPKN",   WHITE, &ScaleKBPKN);
-  add(z[W][PAWN][1]   ^ z[B][ROOK][1],   &EvaluateKPKR);
+  add("KNKBP",   BLACK, &ScaleKNKBP);
-  add(z[W][ROOK][1]   ^ z[B][BISHOP][1], &EvaluateKRKB);
+  add("KRPPKRP", WHITE, &ScaleKRPPKRP);
-  add(z[W][BISHOP][1] ^ z[B][ROOK][1],   &EvaluateKBKR);
+  add("KRPKRPP", BLACK, &ScaleKRPKRPP);
-  add(z[W][ROOK][1]   ^ z[B][KNIGHT][1], &EvaluateKRKN);
+  add("KRPPKRP", WHITE, &ScaleKRPPKRP);
-  add(z[W][KNIGHT][1] ^ z[B][ROOK][1],   &EvaluateKNKR);
+  add("KRPKRPP", BLACK, &ScaleKRPKRPP);
-  add(z[W][QUEEN][1]  ^ z[B][ROOK][1],   &EvaluateKQKR);
-  add(z[W][ROOK][1]   ^ z[B][QUEEN][1],  &EvaluateKRKQ);
-
-  add(z[W][KNIGHT][1] ^ z[W][PAWN][1], W, &ScaleKNPK);
-  add(z[B][KNIGHT][1] ^ z[B][PAWN][1], B, &ScaleKKNP);
-
-  add(z[W][ROOK][1]   ^ z[W][PAWN][1]   ^ z[B][ROOK][1]  , W, &ScaleKRPKR);
-  add(z[W][ROOK][1]   ^ z[B][ROOK][1]   ^ z[B][PAWN][1]  , B, &ScaleKRKRP);
-  add(z[W][BISHOP][1] ^ z[W][PAWN][1]   ^ z[B][BISHOP][1], W, &ScaleKBPKB);
-  add(z[W][BISHOP][1] ^ z[B][BISHOP][1] ^ z[B][PAWN][1]  , B, &ScaleKBKBP);
-  add(z[W][BISHOP][1] ^ z[W][PAWN][1]   ^ z[B][KNIGHT][1], W, &ScaleKBPKN);
-  add(z[W][KNIGHT][1] ^ z[B][BISHOP][1] ^ z[B][PAWN][1]  , B, &ScaleKNKBP);
-
-  add(z[W][ROOK][1] ^ z[W][PAWN][1] ^ z[W][PAWN][2] ^ z[B][ROOK][1] ^ z[B][PAWN][1], W, &ScaleKRPPKRP);
-  add(z[W][ROOK][1] ^ z[W][PAWN][1] ^ z[B][ROOK][1] ^ z[B][PAWN][1] ^ z[B][PAWN][2], B, &ScaleKRPKRPP);
 }
 
-void EndgameFunctions::add(Key k, EndgameEvaluationFunction* f) {
+Key EndgameFunctions::buildKey(const std::string& keyCode) {
 
-  EEFmap.insert(std::pair<Key, EndgameEvaluationFunction*>(k, f));
+    assert(keyCode.length() > 0 && keyCode[0] == 'K');
+    assert(keyCode.length() < 8);
+
+    std::stringstream s;
+    bool upcase = false;
+
+    // Build up a fen substring with the given pieces, note
+    // that the fen string could be of an illegal position.
+    for (size_t i = 0; i < keyCode.length(); i++)
+    {
+        if (keyCode[i] == 'K')
+            upcase = !upcase;
+
+        s << char(upcase? toupper(keyCode[i]) : tolower(keyCode[i]));
+    }
+    s << 8 - keyCode.length() << "/8/8/8/8/8/8/8 w -";
+    return Position(s.str()).get_material_key();
 }
 
-void EndgameFunctions::add(Key k, Color c, ScalingFunction* f) {
+void EndgameFunctions::add(const std::string& keyCode, EndgameEvaluationFunctionBase* f) {
+
+  EEFmap.insert(std::pair<Key, EndgameEvaluationFunctionBase*>(buildKey(keyCode), f));
+}
+
+void EndgameFunctions::add(const std::string& keyCode, Color c, EndgameScalingFunctionBase* f) {
 
   ScalingInfo s = {c, f};
-  ESFmap.insert(std::pair<Key, ScalingInfo>(k, s));
+  ESFmap.insert(std::pair<Key, ScalingInfo>(buildKey(keyCode), s));
 }
 
-EndgameEvaluationFunction* EndgameFunctions::getEEF(Key key) const {
+EndgameEvaluationFunctionBase* EndgameFunctions::getEEF(Key key) const {
 
-  std::map<Key, EndgameEvaluationFunction*>::const_iterator it(EEFmap.find(key));
+  std::map<Key, EndgameEvaluationFunctionBase*>::const_iterator it(EEFmap.find(key));
   return (it != EEFmap.end() ? it->second : NULL);
 }
 
-ScalingFunction* EndgameFunctions::getESF(Key key, Color* c) const {
+EndgameScalingFunctionBase* EndgameFunctions::getESF(Key key, Color* c) const {
 
   std::map<Key, ScalingInfo>::const_iterator it(ESFmap.find(key));
   if (it == ESFmap.end())

src/material.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -52,18 +52,20 @@ public:
   Value mg_value() const;
   Value eg_value() const;
   ScaleFactor scale_factor(const Position& pos, Color c) const;
+  int space_weight() const;
   bool specialized_eval_exists() const;
   Value evaluate(const Position& pos) const;
 
 private:
   void clear();
-  
+
   Key key;
   int16_t mgValue;
   int16_t egValue;
   uint8_t factor[2];
-  EndgameEvaluationFunction* evaluationFunction;
+  EndgameEvaluationFunctionBase* evaluationFunction;
-  ScalingFunction* scalingFunction[2];
+  EndgameScalingFunctionBase* scalingFunction[2];
+  int spaceWeight;
 };
 
 
@@ -120,6 +122,7 @@ inline void MaterialInfo::clear() {
 
   mgValue = egValue = 0;
   factor[WHITE] = factor[BLACK] = uint8_t(SCALE_FACTOR_NORMAL);
+  spaceWeight = 0;
   evaluationFunction = NULL;
   scalingFunction[WHITE] = scalingFunction[BLACK] = NULL;
 }
@@ -144,6 +147,15 @@ inline ScaleFactor MaterialInfo::scale_factor(const Position& pos, Color c) cons
 }
 
 
+/// MaterialInfo::space_weight() simply returns the weight for the space
+/// evaluation for this material configuration.
+
+inline int MaterialInfo::space_weight() const {
+
+  return spaceWeight;
+}
+
+
 /// MaterialInfo::specialized_eval_exists decides whether there is a
 /// specialized evaluation function for the current material configuration,
 /// or if the normal evaluation function should be used.

src/mersenne.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

src/misc.cpp

@@ -29,14 +29,36 @@
 #  include <unistd.h>
 
 #else
+/*
+   (c) Copyright 1992 Eric Backus
 
+   This software may be used freely so long as this copyright notice is
+   left intact. There is no warrantee on this software.
+*/
 #  include <windows.h>
 #  include <time.h>
 #  include "dos.h"
-int gettimeofday(struct timeval * tp, struct timezone * tzp);
+static int gettimeofday(struct timeval* tp, struct timezone*)
+{
+    SYSTEMTIME systime;
+
+    if (tp)
+    {
+        struct tm tmrec;
+        time_t theTime = time(NULL);
+
+        tmrec = *localtime(&theTime);
+        tp->tv_sec = mktime(&tmrec);
+        GetLocalTime(&systime); /* system time */
+
+        tp->tv_usec = systime.wMilliseconds * 1000;
+    }
+    return 0;
+}
 
 #endif
 
+#include <cassert>
 #include <cstdio>
 #include <iomanip>
 #include <iostream>
@@ -44,6 +66,15 @@ int gettimeofday(struct timeval * tp, struct timezone * tzp);
 
 #include "misc.h"
 
+using namespace std;
+
+/// Version number. If this is left empty, the current date (in the format
+/// YYMMDD) is used as a version number.
+
+static const string EngineVersion = "1.3.1";
+static const string AppName = "Stockfish";
+static const string AppTag  = "";
+
 
 ////
 //// Variables
@@ -60,17 +91,65 @@ bool dbg_show_hit_rate = false;
 //// Functions
 ////
 
+void dbg_hit_on(bool b) {
+
+    assert(!dbg_show_mean);
+    dbg_show_hit_rate = true;
+    dbg_cnt0++;
+    if (b)
+        dbg_cnt1++;
+}
+
+void dbg_hit_on_c(bool c, bool b) {
+
+    if (c)
+        dbg_hit_on(b);
+}
+
+void dbg_before() {
+
+    assert(!dbg_show_mean);
+    dbg_show_hit_rate = true;
+    dbg_cnt0++;
+}
+
+void dbg_after() {
+
+    assert(!dbg_show_mean);
+    dbg_show_hit_rate = true;
+    dbg_cnt1++;
+}
+
+void dbg_mean_of(int v) {
+
+    assert(!dbg_show_hit_rate);
+    dbg_show_mean = true;
+    dbg_cnt0++;
+    dbg_cnt1 += v;
+}
+
 void dbg_print_hit_rate() {
 
-  std::cout << "Total " << dbg_cnt0 << " Hit " << dbg_cnt1
+  cout << "Total " << dbg_cnt0 << " Hit " << dbg_cnt1
-            << " hit rate (%) " << (dbg_cnt1*100)/(dbg_cnt0 ? dbg_cnt0 : 1)
+       << " hit rate (%) " << (dbg_cnt1*100)/(dbg_cnt0 ? dbg_cnt0 : 1) << endl;
-            << std::endl;
 }
 
 void dbg_print_mean() {
 
-  std::cout << "Total " << dbg_cnt0 << " Mean "
+  cout << "Total " << dbg_cnt0 << " Mean "
-            << (float)dbg_cnt1 / (dbg_cnt0 ? dbg_cnt0 : 1) << std::endl;
+       << (float)dbg_cnt1 / (dbg_cnt0 ? dbg_cnt0 : 1) << endl;
+}
+
+void dbg_print_hit_rate(ofstream& logFile) {
+
+  logFile << "Total " << dbg_cnt0 << " Hit " << dbg_cnt1
+          << " hit rate (%) " << (dbg_cnt1*100)/(dbg_cnt0 ? dbg_cnt0 : 1) << endl;
+}
+
+void dbg_print_mean(ofstream& logFile) {
+
+  logFile << "Total " << dbg_cnt0 << " Mean "
+          << (float)dbg_cnt1 / (dbg_cnt0 ? dbg_cnt0 : 1) << endl;
 }
 
 /// engine_name() returns the full name of the current Stockfish version.
@@ -78,24 +157,25 @@ void dbg_print_mean() {
 /// program was compiled) or "Stockfish <version number>", depending on whether
 /// the constant EngineVersion (defined in misc.h) is empty.
 
-const std::string engine_name() {
+const string engine_name() {
 
-  if (EngineVersion.empty())
+  if (!EngineVersion.empty())
-  {
-      std::string date(__DATE__); // From compiler, format is "Sep 21 2008"
-      std::string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
-
-      size_t mon = 1 + months.find(date.substr(0, 3)) / 4;
-
-      std::stringstream s;
-      std::string day = (date[4] == ' ' ? date.substr(5, 1) : date.substr(4, 2));
-
-      s << "Stockfish " << date.substr(date.length() - 2) << std::setfill('0')
-        << std::setw(2) << mon << std::setw(2) << day;
-
-      return s.str();
-  } else
       return "Stockfish " + EngineVersion;
+
+  string date(__DATE__); // From compiler, format is "Sep 21 2008"
+  string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
+
+  size_t mon = 1 + months.find(date.substr(0, 3)) / 4;
+
+  stringstream s;
+  string day = (date[4] == ' ' ? date.substr(5, 1) : date.substr(4, 2));
+
+  string name = AppName + " " + AppTag + " ";
+
+  s << name << date.substr(date.length() - 2) << setfill('0')
+    << setw(2) << mon << setw(2) << day;
+
+  return s.str();
 }
 
 

src/misc.h

@@ -26,20 +26,10 @@
 //// Includes
 ////
 
+#include <fstream>
 #include <string>
 
 
-////
-//// Constants
-////
-
-
-/// Version number.  If this is left empty, the current date (in the format
-/// YYMMDD) is used as a version number.
-
-const std::string EngineVersion = "1.01";
-
-
 ////
 //// Macros
 ////
@@ -60,21 +50,21 @@ extern int Bioskey();
 ////
 //// Debug
 ////
-extern long dbg_cnt0;
-extern long dbg_cnt1;
-
-inline void dbg_hit_on(bool b) { dbg_cnt0++; if (b) dbg_cnt1++; }
-inline void dbg_hit_on_c(bool c, bool b) { if (c) dbg_hit_on(b); }
-
-inline void dbg_before() { dbg_cnt0++; }
-inline void dbg_after() { dbg_cnt1++; }
-
-inline void dbg_mean_of(int v) { dbg_cnt0++; dbg_cnt1 += v; }
-
-extern void dbg_print_hit_rate();
-extern void dbg_print_mean();
 
 extern bool dbg_show_mean;
 extern bool dbg_show_hit_rate;
 
+extern long dbg_cnt0;
+extern long dbg_cnt1;
+
+extern void dbg_hit_on(bool b);
+extern void dbg_hit_on_c(bool c, bool b);
+extern void dbg_before();
+extern void dbg_after();
+extern void dbg_mean_of(int v);
+extern void dbg_print_hit_rate();
+extern void dbg_print_mean();
+extern void dbg_print_hit_rate(std::ofstream& logFile);
+extern void dbg_print_mean(std::ofstream& logFile);
+
 #endif // !defined(MISC_H_INCLUDED)

src/move.cpp

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -72,13 +72,13 @@ Move move_from_string(const Position& pos, const std::string& str) {
     }
   }
 
-  if (piece == king_of_color(us))
+  if (piece == piece_of_color_and_type(us, KING))
   {
       // Is this a castling move? A king move is assumed to be a castling
       // move if the destination square is occupied by a friendly rook, or
       // if the distance between the source and destination squares is more
       // than 1.
-      if (pos.piece_on(to) == rook_of_color(us))
+      if (pos.piece_on(to) == piece_of_color_and_type(us, ROOK))
           return make_castle_move(from, to);
 
       else if (square_distance(from, to) > 1)
@@ -87,13 +87,13 @@ Move move_from_string(const Position& pos, const std::string& str) {
           // internal "king captures rook" representation.
           SquareDelta delta = (to > from ? DELTA_E : DELTA_W);
           Square s = from + delta;
-          while (relative_rank(us, s) == RANK_1 && pos.piece_on(s) != rook_of_color(us))
+          while (relative_rank(us, s) == RANK_1 && pos.piece_on(s) != piece_of_color_and_type(us, ROOK))
               s += delta;
 
           return (relative_rank(us, s) == RANK_1 ? make_castle_move(from, s) : MOVE_NONE);
       }
   }
-  else if (piece == pawn_of_color(us))
+  else if (piece == piece_of_color_and_type(us, PAWN))
   {
       // En passant move? We assume that a pawn move is an en passant move
       // without further testing if the destination square is epSquare.
@@ -139,7 +139,7 @@ const std::string move_to_string(Move move) {
 
 /// Overload the << operator, to make it easier to print moves.
 
-std::ostream &operator << (std::ostream &os, Move m) {
+std::ostream &operator << (std::ostream& os, Move m) {
 
   return os << move_to_string(m);
 }

src/move.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -38,10 +38,22 @@
 
 class Position;
 
+/// A move needs 17 bits to be stored
+///
+/// bit  0- 5: destination square (from 0 to 63)
+/// bit  6-11: origin square (from 0 to 63)
+/// bit 12-14: promotion piece type
+/// bit    15: en passant flag
+/// bit    16: castle flag
+///
+/// Special cases are MOVE_NONE and MOVE_NULL. We can sneak these in
+/// because in any normal move destination square is always different
+/// from origin square while MOVE_NONE and MOVE_NULL have the same
+/// origin and destination square, 0 and 1 respectively.
+
 enum Move {
   MOVE_NONE = 0,
-  MOVE_NULL = 65, 
+  MOVE_NULL = 65
-  MOVE_MAX = 0xFFFFFF
 };
 
 
@@ -50,17 +62,20 @@ struct MoveStack {
   int score;
 };
 
+// Note that operator< is set up such that std::sort() will sort in descending order
+inline bool operator<(const MoveStack& f, const MoveStack& s) { return s.score < f.score; }
+
 
 ////
 //// Inline functions
 ////
 
 inline Square move_from(Move m) {
-  return Square((int(m) >> 6) & 077);
+  return Square((int(m) >> 6) & 0x3F);
 }
 
 inline Square move_to(Move m) {
-  return Square(m & 077);
+  return Square(m & 0x3F);
 }
 
 inline PieceType move_promotion(Move m) {

src/movegen.cpp

@@ -35,73 +35,93 @@
 
 namespace {
 
-  // Function
+  enum CastlingSide {
-  MoveStack* generate_castle_moves(const Position&, MoveStack*);
+    KING_SIDE,
+    QUEEN_SIDE
+  };
 
-  // Template generate_pawn_captures() with specializations
+  enum MoveType {
-  template<Color, Color, Bitboard, SquareDelta, SquareDelta, SquareDelta>
+    CAPTURE,
-  MoveStack* do_generate_pawn_captures(const Position& pos, MoveStack* mlist);
+    NON_CAPTURE
+  };
 
-  template<Color>
+  // Functions
-  inline MoveStack* generate_pawn_captures(const Position& p, MoveStack* m) {
+  bool castling_is_check(const Position&, CastlingSide);
-      return do_generate_pawn_captures<WHITE, BLACK, Rank8BB, DELTA_NE, DELTA_NW, DELTA_N>(p, m);
-  }
-  template<>
-  inline MoveStack* generate_pawn_captures<BLACK>(const Position& p, MoveStack* m) {
-      return do_generate_pawn_captures<BLACK, WHITE, Rank1BB, DELTA_SE, DELTA_SW, DELTA_S>(p, m);
-  }
 
-  // Template generate_pawn_noncaptures() with specializations
+  // Helper templates
-  template<Color, Color, Bitboard, Bitboard, SquareDelta, SquareDelta, SquareDelta>
+  template<CastlingSide Side>
-  MoveStack* do_generate_pawn_noncaptures(const Position& pos, MoveStack* mlist);
+  MoveStack* generate_castle_moves(const Position& pos, MoveStack* mlist);
 
-  template<Color>
-  inline MoveStack* generate_pawn_noncaptures(const Position& p, MoveStack* m) {
-      return do_generate_pawn_noncaptures<WHITE, BLACK, Rank8BB, Rank3BB, DELTA_NE, DELTA_NW, DELTA_N>(p, m);
-  }
-  template<>
-  inline MoveStack* generate_pawn_noncaptures<BLACK>(const Position& p, MoveStack* m) {
-      return do_generate_pawn_noncaptures<BLACK, WHITE, Rank1BB, Rank6BB, DELTA_SE, DELTA_SW, DELTA_S>(p, m);
-  }
-
-  // Template generate_pawn_blocking_evasions() with specializations
   template<Color Us, Rank, Bitboard, SquareDelta>
-  MoveStack* do_generate_pawn_blocking_evasions(const Position& pos, Bitboard not_pinned,
+  MoveStack* generate_pawn_blocking_evasions(const Position&, Bitboard, Bitboard, MoveStack*);
-                                                Bitboard blockSquares, MoveStack* mlist);
+
-  template<Color>
+  template<Color, Color, Bitboard, SquareDelta, SquareDelta, SquareDelta>
-  inline MoveStack* generate_pawn_blocking_evasions(const Position& p, Bitboard np, Bitboard bs, MoveStack* m) {
+  MoveStack* generate_pawn_captures(const Position& pos, MoveStack* mlist);
-      return do_generate_pawn_blocking_evasions<WHITE, RANK_8, Rank3BB, DELTA_N>(p, np, bs, m);
+
-  }
+  template<Color, Color, Bitboard, Bitboard, SquareDelta, SquareDelta, SquareDelta>
-  template<>
+  MoveStack* generate_pawn_noncaptures(const Position& pos, MoveStack* mlist);
-  inline MoveStack* generate_pawn_blocking_evasions<BLACK>(const Position& p, Bitboard np, Bitboard bs, MoveStack* m) {
-      return do_generate_pawn_blocking_evasions<BLACK, RANK_1, Rank6BB, DELTA_S>(p, np, bs, m);
-  }
 
-  // Template generate_pawn_checks() with specializations
   template<Color, Color, Bitboard, Bitboard, SquareDelta>
-  MoveStack* do_generate_pawn_checks(const Position&, Bitboard, Square, MoveStack*);
+  MoveStack* generate_pawn_checks(const Position&, Bitboard, Square, MoveStack*);
 
-  template<Color>
+  template<Color Us, SquareDelta Direction>
-  inline MoveStack* generate_pawn_checks(const Position& p, Bitboard dc, Square ksq, MoveStack* m) {
+  inline Bitboard move_pawns(Bitboard p) {
-      return do_generate_pawn_checks<WHITE, BLACK, Rank8BB, Rank3BB, DELTA_N>(p, dc, ksq, m);
+
+    if (Direction == DELTA_N)
+        return Us == WHITE ? p << 8 : p >> 8;
+    else if (Direction == DELTA_NE)
+        return Us == WHITE ? p << 9 : p >> 7;
+    else if (Direction == DELTA_NW)
+        return Us == WHITE ? p << 7 : p >> 9;
+    else
+        return p;
   }
+
+  // Template generate_piece_checks() with specializations
+  template<PieceType>
+  MoveStack* generate_piece_checks(const Position&, MoveStack*, Color, Bitboard, Square);
+
   template<>
-  inline MoveStack* generate_pawn_checks<BLACK>(const Position& p, Bitboard dc, Square ksq, MoveStack* m) {
+  inline MoveStack* generate_piece_checks<PAWN>(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) {
-      return do_generate_pawn_checks<BLACK, WHITE, Rank1BB, Rank6BB, DELTA_S>(p, dc, ksq, m);
+
+    if (us == WHITE)
+        return generate_pawn_checks<WHITE, BLACK, Rank8BB, Rank3BB, DELTA_N>(p, dc, ksq, m);
+    else
+        return generate_pawn_checks<BLACK, WHITE, Rank1BB, Rank6BB, DELTA_S>(p, dc, ksq, m);
+
   }
 
-  // non-pawn templates
+  // Template generate_piece_moves() with specializations and overloads
   template<PieceType>
   MoveStack* generate_piece_moves(const Position&, MoveStack*, Color us, Bitboard);
+
   template<>
-  MoveStack* generate_piece_moves<KING>(const Position& pos, MoveStack* mlist, Color us, Bitboard target);
+  MoveStack* generate_piece_moves<KING>(const Position&, MoveStack*, Color, Bitboard);
+
+  template<PieceType Piece, MoveType Type>
+  inline MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us) {
+
+      assert(Piece == PAWN);
+
+      if (Type == CAPTURE)
+          return (us == WHITE ? generate_pawn_captures<WHITE, BLACK, Rank8BB, DELTA_NE, DELTA_NW, DELTA_N>(p, m)
+                              : generate_pawn_captures<BLACK, WHITE, Rank1BB, DELTA_SE, DELTA_SW, DELTA_S>(p, m));
+      else
+          return (us == WHITE ? generate_pawn_noncaptures<WHITE, BLACK, Rank8BB, Rank3BB, DELTA_NE, DELTA_NW, DELTA_N>(p, m)
+                              : generate_pawn_noncaptures<BLACK, WHITE, Rank1BB, Rank6BB, DELTA_SE, DELTA_SW, DELTA_S>(p, m));
+  }
 
   template<PieceType>
-  MoveStack* generate_piece_checks(const Position&, Bitboard, Bitboard, Square, MoveStack*);
+  MoveStack* generate_piece_moves(const Position&, MoveStack*, Color us, Bitboard, Bitboard);
-  MoveStack* generate_piece_checks_king(const Position&, Square, Bitboard, Square, MoveStack*);
 
-  template<PieceType>
+  template<>
-  MoveStack* generate_piece_blocking_evasions(const Position&, Bitboard, Bitboard, MoveStack*);
+  inline MoveStack* generate_piece_moves<PAWN>(const Position& p, MoveStack* m,
+                                               Color us, Bitboard t, Bitboard pnd) {
+    if (us == WHITE)
+        return generate_pawn_blocking_evasions<WHITE, RANK_8, Rank3BB, DELTA_N>(p, pnd, t, m);
+    else
+        return generate_pawn_blocking_evasions<BLACK, RANK_1, Rank6BB, DELTA_S>(p, pnd, t, m);
+  }
 }
 
 
@@ -122,22 +142,18 @@ int generate_captures(const Position& pos, MoveStack* mlist) {
   Bitboard target = pos.pieces_of_color(opposite_color(us));
   MoveStack* mlist_start = mlist;
 
-  if (us == WHITE)
-      mlist = generate_pawn_captures<WHITE>(pos, mlist);
-  else
-      mlist = generate_pawn_captures<BLACK>(pos, mlist);
-
-  mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
-  mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
-  mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
   mlist = generate_piece_moves<QUEEN>(pos, mlist, us, target);
+  mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
+  mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
+  mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
+  mlist = generate_piece_moves<PAWN, CAPTURE>(pos, mlist, us);
   mlist = generate_piece_moves<KING>(pos, mlist, us, target);
   return int(mlist - mlist_start);
 }
 
 
 /// generate_noncaptures() generates all pseudo-legal non-captures and
-/// underpromotions.  The return value is the number of moves generated.
+/// underpromotions. The return value is the number of moves generated.
 
 int generate_noncaptures(const Position& pos, MoveStack* mlist) {
 
@@ -148,26 +164,22 @@ int generate_noncaptures(const Position& pos, MoveStack* mlist) {
   Bitboard target = pos.empty_squares();
   MoveStack* mlist_start = mlist;
 
-  if (us == WHITE)
+  mlist = generate_piece_moves<PAWN, NON_CAPTURE>(pos, mlist, us);
-      mlist = generate_pawn_noncaptures<WHITE>(pos, mlist);
-  else
-      mlist = generate_pawn_noncaptures<BLACK>(pos, mlist);
-
   mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
   mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
   mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
   mlist = generate_piece_moves<QUEEN>(pos, mlist, us, target);
   mlist = generate_piece_moves<KING>(pos, mlist, us, target);
-  mlist = generate_castle_moves(pos, mlist);
+  mlist = generate_castle_moves<KING_SIDE>(pos, mlist);
+  mlist = generate_castle_moves<QUEEN_SIDE>(pos, mlist);
   return int(mlist - mlist_start);
 }
 
 
-/// generate_checks() generates all pseudo-legal non-capturing, non-promoting
+/// generate_non_capture_checks() generates all pseudo-legal non-capturing,
-/// checks, except castling moves (will add this later).  It returns the
+/// non-promoting checks. It returns the number of generated moves.
-/// number of generated moves.
 
-int generate_checks(const Position& pos, MoveStack* mlist, Bitboard dc) {
+int generate_non_capture_checks(const Position& pos, MoveStack* mlist, Bitboard dc) {
 
   assert(pos.is_ok());
   assert(!pos.is_check());
@@ -176,48 +188,36 @@ int generate_checks(const Position& pos, MoveStack* mlist, Bitboard dc) {
   Square ksq = pos.king_square(opposite_color(us));
   MoveStack* mlist_start = mlist;
 
-  assert(pos.piece_on(ksq) == king_of_color(opposite_color(us)));
+  assert(pos.piece_on(ksq) == piece_of_color_and_type(opposite_color(us), KING));
-
-  dc = pos.discovered_check_candidates(us);
-
-  // Pawn moves
-  if (us == WHITE)
-     mlist = generate_pawn_checks<WHITE>(pos, dc, ksq, mlist);
-  else
-     mlist = generate_pawn_checks<BLACK>(pos, dc, ksq, mlist);
 
   // Pieces moves
-  Bitboard b = pos.knights(us);
+  mlist = generate_piece_checks<PAWN>(pos, mlist, us, dc, ksq);
-  if (b)
+  mlist = generate_piece_checks<KNIGHT>(pos, mlist, us, dc, ksq);
-      mlist = generate_piece_checks<KNIGHT>(pos, b, dc, ksq, mlist);
+  mlist = generate_piece_checks<BISHOP>(pos, mlist, us, dc, ksq);
+  mlist = generate_piece_checks<ROOK>(pos, mlist, us, dc, ksq);
+  mlist = generate_piece_checks<QUEEN>(pos, mlist, us, dc, ksq);
+  mlist = generate_piece_checks<KING>(pos, mlist, us, dc, ksq);
 
-  b = pos.bishops(us);
+  // Castling moves that give check. Very rare but nice to have!
-  if (b)
+  if (   pos.can_castle_queenside(us)
-      mlist = generate_piece_checks<BISHOP>(pos, b, dc, ksq, mlist);
+      && (square_rank(ksq) == square_rank(pos.king_square(us)) || square_file(ksq) == FILE_D)
+      && castling_is_check(pos, QUEEN_SIDE))
+      mlist = generate_castle_moves<QUEEN_SIDE>(pos, mlist);
 
-  b = pos.rooks(us);
+  if (   pos.can_castle_kingside(us)
-  if (b)
+      && (square_rank(ksq) == square_rank(pos.king_square(us)) || square_file(ksq) == FILE_F)
-      mlist = generate_piece_checks<ROOK>(pos, b, dc, ksq, mlist);
+      && castling_is_check(pos, KING_SIDE))
-
+      mlist = generate_castle_moves<KING_SIDE>(pos, mlist);
-  b = pos.queens(us);
-  if (b)
-      mlist = generate_piece_checks<QUEEN>(pos, b, dc, ksq, mlist);
-
-  // Hopefully we always have a king ;-)
-  mlist = generate_piece_checks_king(pos, pos.king_square(us), dc, ksq, mlist);
-
-  // TODO: Castling moves!
 
   return int(mlist - mlist_start);
 }
 
 
 /// generate_evasions() generates all check evasions when the side to move is
-/// in check.  Unlike the other move generation functions, this one generates
+/// in check. Unlike the other move generation functions, this one generates
-/// only legal moves.  It returns the number of generated moves.  This
+/// only legal moves. It returns the number of generated moves.
-/// function is very ugly, and needs cleaning up some time later.  FIXME
 
-int generate_evasions(const Position& pos, MoveStack* mlist) {
+int generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pinned) {
 
   assert(pos.is_ok());
   assert(pos.is_check());
@@ -228,49 +228,56 @@ int generate_evasions(const Position& pos, MoveStack* mlist) {
   Square ksq = pos.king_square(us);
   MoveStack* mlist_start = mlist;
 
-  assert(pos.piece_on(ksq) == king_of_color(us));
+  assert(pos.piece_on(ksq) == piece_of_color_and_type(us, KING));
+
+  // The bitboard of occupied pieces without our king
+  Bitboard b_noKing = pos.occupied_squares();
+  clear_bit(&b_noKing, ksq);
+
+  // Find squares attacked by slider checkers, we will
+  // remove them from king evasions set so to avoid a couple
+  // of cycles in the slow king evasions legality check loop
+  // and to be able to use square_is_attacked().
+  Bitboard checkers = pos.checkers();
+  Bitboard checkersAttacks = EmptyBoardBB;
+  Bitboard b = checkers & (pos.queens() | pos.bishops());
+  while (b)
+  {
+      from = pop_1st_bit(&b);
+      checkersAttacks |= bishop_attacks_bb(from, b_noKing);
+  }
+
+  b = checkers & (pos.queens() | pos.rooks());
+  while (b)
+  {
+      from = pop_1st_bit(&b);
+      checkersAttacks |= rook_attacks_bb(from, b_noKing);
+  }
 
   // Generate evasions for king
-  Bitboard b1 = pos.piece_attacks<KING>(ksq) & ~pos.pieces_of_color(us);
+  Bitboard b1 = pos.piece_attacks<KING>(ksq) & ~pos.pieces_of_color(us) & ~checkersAttacks;
-  Bitboard b2 = pos.occupied_squares();
-  clear_bit(&b2, ksq);
-
   while (b1)
   {
-    to = pop_1st_bit(&b1);
+      to = pop_1st_bit(&b1);
-
+      // Note that we can use square_is_attacked() only because we
-    // Make sure 'to' is not attacked by the other side. This is a bit ugly,
+      // have already removed slider checkers.
-    // because we can't use Position::square_is_attacked. Instead we use
+      if (!pos.square_is_attacked(to, them))
-    // the low-level bishop_attacks_bb and rook_attacks_bb with the bitboard
+          (*mlist++).move = make_move(ksq, to);
-    // b2 (the occupied squares with the king removed) in order to test whether
-    // the king will remain in check on the destination square.
-    if (!(   (pos.piece_attacks<KNIGHT>(to) & pos.knights(them))
-          || (pos.pawn_attacks(us, to)      & pos.pawns(them))
-          || (bishop_attacks_bb(to, b2)     & pos.bishops_and_queens(them))
-          || (rook_attacks_bb(to, b2)       & pos.rooks_and_queens(them))
-          || (pos.piece_attacks<KING>(to)   & pos.kings(them))))
-
-        (*mlist++).move = make_move(ksq, to);
   }
 
   // Generate evasions for other pieces only if not double check. We use a
   // simple bit twiddling hack here rather than calling count_1s in order to
   // save some time (we know that pos.checkers() has at most two nonzero bits).
-  Bitboard checkers = pos.checkers();
-
   if (!(checkers & (checkers - 1))) // Only one bit set?
   {
       Square checksq = first_1(checkers);
 
       assert(pos.color_of_piece_on(checksq) == them);
 
-      // Find pinned pieces
-      Bitboard not_pinned = ~pos.pinned_pieces(us);
-
       // Generate captures of the checking piece
 
       // Pawn captures
-      b1 = pos.pawn_attacks(them, checksq) & pos.pawns(us) & not_pinned;
+      b1 = pos.pawn_attacks(them, checksq) & pos.pawns(us) & ~pinned;
       while (b1)
       {
           from = pop_1st_bit(&b1);
@@ -287,7 +294,7 @@ int generate_evasions(const Position& pos, MoveStack* mlist) {
       // Pieces captures
       b1 = (  (pos.piece_attacks<KNIGHT>(checksq) & pos.knights(us))
             | (pos.piece_attacks<BISHOP>(checksq) & pos.bishops_and_queens(us))
-            | (pos.piece_attacks<ROOK>(checksq)   & pos.rooks_and_queens(us)) ) & not_pinned;
+            | (pos.piece_attacks<ROOK>(checksq)   & pos.rooks_and_queens(us)) ) & ~pinned;
 
       while (b1)
       {
@@ -296,77 +303,56 @@ int generate_evasions(const Position& pos, MoveStack* mlist) {
       }
 
       // Blocking check evasions are possible only if the checking piece is
-      // a slider
+      // a slider.
       if (checkers & pos.sliders())
       {
           Bitboard blockSquares = squares_between(checksq, ksq);
 
           assert((pos.occupied_squares() & blockSquares) == EmptyBoardBB);
 
-          // Pawn moves. Because a blocking evasion can never be a capture, we
+          if (blockSquares != EmptyBoardBB)
-          // only generate pawn pushes.
+          {
-          if (us == WHITE)
+              mlist = generate_piece_moves<PAWN>(pos, mlist, us, blockSquares, pinned);
-              mlist = generate_pawn_blocking_evasions<WHITE>(pos, not_pinned, blockSquares, mlist);
+              mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, blockSquares, pinned);
-          else
+              mlist = generate_piece_moves<BISHOP>(pos, mlist, us, blockSquares, pinned);
-              mlist = generate_pawn_blocking_evasions<BLACK>(pos, not_pinned, blockSquares, mlist);
+              mlist = generate_piece_moves<ROOK>(pos, mlist, us, blockSquares, pinned);
+              mlist = generate_piece_moves<QUEEN>(pos, mlist, us, blockSquares, pinned);
+          }
+      }
 
-          // Pieces moves
+      // Finally, the special case of en passant captures. An en passant
-          b1 = pos.knights(us) & not_pinned;
+      // capture can only be a check evasion if the check is not a discovered
-          if (b1)
+      // check. If pos.ep_square() is set, the last move made must have been
-              mlist = generate_piece_blocking_evasions<KNIGHT>(pos, b1, blockSquares, mlist);
+      // a double pawn push. If, furthermore, the checking piece is a pawn,
+      // an en passant check evasion may be possible.
+      if (pos.ep_square() != SQ_NONE && (checkers & pos.pawns(them)))
+      {
+          to = pos.ep_square();
+          b1 = pos.pawn_attacks(them, to) & pos.pawns(us);
 
-          b1 = pos.bishops(us) & not_pinned;
+          // The checking pawn cannot be a discovered (bishop) check candidate
-          if (b1)
+          // otherwise we were in check also before last double push move.
-              mlist = generate_piece_blocking_evasions<BISHOP>(pos, b1, blockSquares, mlist);
+          assert(!bit_is_set(pos.discovered_check_candidates(them), checksq));
+          assert(count_1s(b1) == 1 || count_1s(b1) == 2);
 
-          b1 = pos.rooks(us) & not_pinned;
+          b1 &= ~pinned;
-          if (b1)
+          while (b1)
-              mlist = generate_piece_blocking_evasions<ROOK>(pos, b1, blockSquares, mlist);
+          {
-
+              from = pop_1st_bit(&b1);
-          b1 = pos.queens(us) & not_pinned;
+              // Move is always legal because checking pawn is not a discovered
-          if (b1)
+              // check candidate and our capturing pawn has been already tested
-              mlist = generate_piece_blocking_evasions<QUEEN>(pos, b1, blockSquares, mlist);
+              // against pinned pieces.
-    }
+              (*mlist++).move = make_ep_move(from, to);
-
+          }
-    // Finally, the ugly special case of en passant captures. An en passant
+      }
-    // capture can only be a check evasion if the check is not a discovered
-    // check. If pos.ep_square() is set, the last move made must have been
-    // a double pawn push. If, furthermore, the checking piece is a pawn,
-    // an en passant check evasion may be possible.
-    if (pos.ep_square() != SQ_NONE && (checkers & pos.pawns(them)))
-    {
-        to = pos.ep_square();
-        b1 = pos.pawn_attacks(them, to) & pos.pawns(us);
-
-        assert(b1 != EmptyBoardBB);
-
-        b1 &= not_pinned;
-        while (b1)
-        {
-            from = pop_1st_bit(&b1);
-
-            // Before generating the move, we have to make sure it is legal.
-            // This is somewhat tricky, because the two disappearing pawns may
-            // cause new "discovered checks".  We test this by removing the
-            // two relevant bits from the occupied squares bitboard, and using
-            // the low-level bitboard functions for bishop and rook attacks.
-            b2 = pos.occupied_squares();
-            clear_bit(&b2, from);
-            clear_bit(&b2, checksq);
-            if (!(  (bishop_attacks_bb(ksq, b2) & pos.bishops_and_queens(them))
-                  ||(rook_attacks_bb(ksq, b2)   & pos.rooks_and_queens(them))))
-
-                 (*mlist++).move = make_ep_move(from, to);
-        }
-    }
   }
   return int(mlist - mlist_start);
 }
 
 
 /// generate_legal_moves() computes a complete list of legal moves in the
-/// current position.  This function is not very fast, and should be used
+/// current position. This function is not very fast, and should be used
-/// only in situations where performance is unimportant.  It wouldn't be
+/// only in situations where performance is unimportant. It wouldn't be
 /// very hard to write an efficient legal move generator, but for the moment
 /// we don't need it.
 
@@ -374,15 +360,15 @@ int generate_legal_moves(const Position& pos, MoveStack* mlist) {
 
   assert(pos.is_ok());
 
+  Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
+
   if (pos.is_check())
-      return generate_evasions(pos, mlist);
+      return generate_evasions(pos, mlist, pinned);
 
   // Generate pseudo-legal moves
   int n = generate_captures(pos, mlist);
   n += generate_noncaptures(pos, mlist + n);
 
-  Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
-
   // Remove illegal moves from the list
   for (int i = 0; i < n; i++)
       if (!pos.pl_move_is_legal(mlist[i].move, pinned))
@@ -427,7 +413,7 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
           return false;
 
       assert(pos.square_is_empty(to));
-      assert(pos.piece_on(to - pawn_push(us)) == pawn_of_color(them));
+      assert(pos.piece_on(to - pawn_push(us)) == piece_of_color_and_type(them, PAWN));
 
       // The move is pseudo-legal, check if it is also legal
       return pos.pl_move_is_legal(m, pinned);
@@ -444,7 +430,7 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
 
       assert(from == pos.king_square(us));
       assert(to == pos.initial_kr_square(us));
-      assert(pos.piece_on(to) == rook_of_color(us));
+      assert(pos.piece_on(to) == piece_of_color_and_type(us, ROOK));
 
       Square g1 = relative_square(us, SQ_G1);
       Square f1 = relative_square(us, SQ_F1);
@@ -477,7 +463,7 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
 
       assert(from == pos.king_square(us));
       assert(to == pos.initial_qr_square(us));
-      assert(pos.piece_on(to) == rook_of_color(us));
+      assert(pos.piece_on(to) == piece_of_color_and_type(us, ROOK));
 
       Square c1 = relative_square(us, SQ_C1);
       Square d1 = relative_square(us, SQ_D1);
@@ -494,8 +480,8 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
               illegal = true;
 
       if (   square_file(to) == FILE_B
-          && (   pos.piece_on(to + DELTA_W) == rook_of_color(them)
+          && (   pos.piece_on(to + DELTA_W) == piece_of_color_and_type(them, ROOK)
-              || pos.piece_on(to + DELTA_W) == queen_of_color(them)))
+              || pos.piece_on(to + DELTA_W) == piece_of_color_and_type(them, QUEEN)))
           illegal = true;
 
       return !illegal;
@@ -566,7 +552,7 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
   }
 
   // Luckly we can handle all the other pieces in one go
-  return (   pos.piece_attacks_square(from, to)
+  return (   pos.piece_attacks_square(pos.piece_on(from), from, to)
           && pos.pl_move_is_legal(m, pinned)
           && !move_promotion(m));
 }
@@ -589,6 +575,24 @@ namespace {
     return mlist;
   }
 
+  template<PieceType Piece>
+  MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist,
+                                  Color us, Bitboard target, Bitboard pinned) {
+    Square from;
+    Bitboard b;
+
+    for (int i = 0, e = pos.piece_count(us, Piece); i < e; i++)
+    {
+        from = pos.piece_list(us, Piece, i);
+        if (pinned && bit_is_set(pinned, from))
+            continue;
+
+        b = pos.piece_attacks<Piece>(from) & target;
+        SERIALIZE_MOVES(b);
+    }
+    return mlist;
+  }
+
   template<>
   MoveStack* generate_piece_moves<KING>(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
 
@@ -600,30 +604,17 @@ namespace {
     return mlist;
   }
 
-  template<PieceType Piece>
-  MoveStack* generate_piece_blocking_evasions(const Position& pos, Bitboard b,
-                                              Bitboard blockSquares, MoveStack* mlist) {
-    while (b)
-    {
-        Square from = pop_1st_bit(&b);
-        Bitboard bb = pos.piece_attacks<Piece>(from) & blockSquares;
-        SERIALIZE_MOVES(bb);
-    }
-    return mlist;
-  }
-
-
   template<Color Us, Color Them, Bitboard TRank8BB, SquareDelta TDELTA_NE,
            SquareDelta TDELTA_NW, SquareDelta TDELTA_N
           >
-  MoveStack* do_generate_pawn_captures(const Position& pos, MoveStack* mlist) {
+  MoveStack* generate_pawn_captures(const Position& pos, MoveStack* mlist) {
 
     Square to;
     Bitboard pawns = pos.pawns(Us);
     Bitboard enemyPieces = pos.pieces_of_color(Them);
 
     // Captures in the a1-h8 (a8-h1 for black) direction
-    Bitboard b1 = (Us == WHITE ? pawns << 9 : pawns >> 7) & ~FileABB & enemyPieces;
+    Bitboard b1 = move_pawns<Us, DELTA_NE>(pawns) & ~FileABB & enemyPieces;
 
     // Capturing promotions
     Bitboard b2 = b1 & TRank8BB;
@@ -642,7 +633,7 @@ namespace {
     }
 
     // Captures in the h1-a8 (h8-a1 for black) direction
-    b1 = (Us == WHITE ? pawns << 7 : pawns >> 9) & ~FileHBB & enemyPieces;
+    b1 = move_pawns<Us, DELTA_NW>(pawns) & ~FileHBB & enemyPieces;
 
     // Capturing promotions
     b2 = b1 & TRank8BB;
@@ -661,7 +652,7 @@ namespace {
     }
 
     // Non-capturing promotions
-    b1 = (Us == WHITE ? pawns << 8 : pawns >> 8) & pos.empty_squares() & TRank8BB;
+    b1 = move_pawns<Us, DELTA_N>(pawns) & pos.empty_squares() & TRank8BB;
     while (b1)
     {
         to = pop_1st_bit(&b1);
@@ -689,7 +680,7 @@ namespace {
   template<Color Us, Color Them, Bitboard TRank8BB, Bitboard TRank3BB,
            SquareDelta TDELTA_NE, SquareDelta TDELTA_NW, SquareDelta TDELTA_N
           >
-  MoveStack* do_generate_pawn_noncaptures(const Position& pos, MoveStack* mlist) {
+  MoveStack* generate_pawn_noncaptures(const Position& pos, MoveStack* mlist) {
 
     Bitboard pawns = pos.pawns(Us);
     Bitboard enemyPieces = pos.pieces_of_color(Them);
@@ -698,7 +689,7 @@ namespace {
     Square to;
 
     // Underpromotion captures in the a1-h8 (a8-h1 for black) direction
-    b1 = (Us == WHITE ? pawns << 9 : pawns >> 7) & ~FileABB & enemyPieces & TRank8BB;
+    b1 = move_pawns<Us, DELTA_NE>(pawns) & ~FileABB & enemyPieces & TRank8BB;
     while (b1)
     {
         to = pop_1st_bit(&b1);
@@ -708,7 +699,7 @@ namespace {
     }
 
     // Underpromotion captures in the h1-a8 (h8-a1 for black) direction
-    b1 = (Us == WHITE ? pawns << 7 : pawns >> 9) & ~FileHBB & enemyPieces & TRank8BB;
+    b1 = move_pawns<Us, DELTA_NW>(pawns) & ~FileHBB & enemyPieces & TRank8BB;
     while (b1)
     {
         to = pop_1st_bit(&b1);
@@ -718,14 +709,14 @@ namespace {
     }
 
     // Single pawn pushes
-    b1 = (Us == WHITE ? pawns << 8 : pawns >> 8) & emptySquares;
+    b1 = move_pawns<Us, DELTA_N>(pawns) & emptySquares;
     b2 = b1 & TRank8BB;
     while (b2)
     {
-      to = pop_1st_bit(&b2);
+        to = pop_1st_bit(&b2);
-      (*mlist++).move = make_promotion_move(to - TDELTA_N, to, ROOK);
+        (*mlist++).move = make_promotion_move(to - TDELTA_N, to, ROOK);
-      (*mlist++).move = make_promotion_move(to - TDELTA_N, to, BISHOP);
+        (*mlist++).move = make_promotion_move(to - TDELTA_N, to, BISHOP);
-      (*mlist++).move = make_promotion_move(to - TDELTA_N, to, KNIGHT);
+        (*mlist++).move = make_promotion_move(to - TDELTA_N, to, KNIGHT);
     }
     b2 = b1 & ~TRank8BB;
     while (b2)
@@ -735,50 +726,53 @@ namespace {
     }
 
     // Double pawn pushes
-    b2 = (Us == WHITE ? (b1 & TRank3BB) << 8 : (b1 & TRank3BB) >> 8) & emptySquares;
+    b2 = move_pawns<Us, DELTA_N>(b1 & TRank3BB) & emptySquares;
     while (b2)
     {
-      to = pop_1st_bit(&b2);
+        to = pop_1st_bit(&b2);
-      (*mlist++).move = make_move(to - TDELTA_N - TDELTA_N, to);
+        (*mlist++).move = make_move(to - TDELTA_N - TDELTA_N, to);
     }
     return mlist;
   }
 
 
   template<Color Us, Color Them, Bitboard TRank8BB, Bitboard TRank3BB, SquareDelta TDELTA_N>
-  MoveStack* do_generate_pawn_checks(const Position& pos, Bitboard dc, Square ksq, MoveStack* mlist)
+  MoveStack* generate_pawn_checks(const Position& pos, Bitboard dc, Square ksq, MoveStack* mlist)
   {
-    // Pawn moves which give discovered check. This is possible only if the
+    // Find all friendly pawns not on the enemy king's file
-    // pawn is not on the same file as the enemy king, because we don't
+    Bitboard b1, b2, b3;
-    // generate captures.
     Bitboard empty = pos.empty_squares();
 
-    // Find all friendly pawns not on the enemy king's file
+    if (dc != EmptyBoardBB)
-    Bitboard b1 = pos.pawns(Us) & ~file_bb(ksq), b2, b3;
-
-    // Discovered checks, single pawn pushes
-    b2 = b3 = (Us == WHITE ? (b1 & dc) << 8 : (b1 & dc) >> 8) & ~TRank8BB & empty;
-    while (b3)
     {
-        Square to = pop_1st_bit(&b3);
+        // Pawn moves which gives discovered check. This is possible only if the
-        (*mlist++).move = make_move(to - TDELTA_N, to);
+        // pawn is not on the same file as the enemy king, because we don't
-    }
+        // generate captures.
+        b1 = pos.pawns(Us) & ~file_bb(ksq);
 
-    // Discovered checks, double pawn pushes
+        // Discovered checks, single pawn pushes, no promotions
-    b3 = (Us == WHITE ? (b2 & TRank3BB) << 8 : (b2 & TRank3BB) >> 8) & empty;
+        b2 = b3 = move_pawns<Us, DELTA_N>(b1 & dc) & empty & ~TRank8BB;
-    while (b3)
+        while (b3)
-    {
+        {
-        Square to = pop_1st_bit(&b3);
+            Square to = pop_1st_bit(&b3);
-        (*mlist++).move = make_move(to - TDELTA_N - TDELTA_N, to);
+            (*mlist++).move = make_move(to - TDELTA_N, to);
+        }
+
+        // Discovered checks, double pawn pushes
+        b3 = move_pawns<Us, DELTA_N>(b2 & TRank3BB) & empty;
+        while (b3)
+        {
+            Square to = pop_1st_bit(&b3);
+            (*mlist++).move = make_move(to - TDELTA_N - TDELTA_N, to);
+        }
     }
 
     // Direct checks. These are possible only for pawns on neighboring files
-    // of the enemy king
+    // of the enemy king.
-
+    b1 = pos.pawns(Us) & neighboring_files_bb(ksq) & ~dc;
-    b1 &= (~dc & neighboring_files_bb(ksq)); // FIXME why ~dc ??
 
     // Direct checks, single pawn pushes
-    b2 = (Us == WHITE ? b1 << 8 : b1 >> 8) & empty;
+    b2 = move_pawns<Us, DELTA_N>(b1) & empty;
     b3 = b2 & pos.pawn_attacks(Them, ksq);
     while (b3)
     {
@@ -787,10 +781,7 @@ namespace {
     }
 
     // Direct checks, double pawn pushes
-    b3 =  (Us == WHITE ? (b2 & TRank3BB) << 8 : (b2 & TRank3BB) >> 8)
+    b3 =  move_pawns<Us, DELTA_N>(b2 & TRank3BB) & empty & pos.pawn_attacks(Them, ksq);
-        & empty
-        & pos.pawn_attacks(Them, ksq);
-
     while (b3)
     {
         Square to = pop_1st_bit(&b3);
@@ -800,52 +791,57 @@ namespace {
   }
 
   template<PieceType Piece>
-  MoveStack* generate_piece_checks(const Position& pos, Bitboard target, Bitboard dc,
+  MoveStack* generate_piece_checks(const Position& pos, MoveStack* mlist, Color us,
-                                   Square ksq, MoveStack* mlist) {
+                                   Bitboard dc, Square ksq) {
+
+    Bitboard target = pos.pieces_of_color_and_type(us, Piece);
+
     // Discovered checks
     Bitboard b = target & dc;
     while (b)
     {
         Square from = pop_1st_bit(&b);
         Bitboard bb = pos.piece_attacks<Piece>(from) & pos.empty_squares();
+        if (Piece == KING)
+            bb &= ~QueenPseudoAttacks[ksq];
+
         SERIALIZE_MOVES(bb);
     }
+
     // Direct checks
     b = target & ~dc;
+    if (Piece == KING || !b)
+        return mlist;
+
     Bitboard checkSqs = pos.piece_attacks<Piece>(ksq) & pos.empty_squares();
+    if (!checkSqs)
+        return mlist;
+
     while (b)
     {
         Square from = pop_1st_bit(&b);
+        if (   (Piece == QUEEN  && !(QueenPseudoAttacks[from]  & checkSqs))
+            || (Piece == ROOK   && !(RookPseudoAttacks[from]   & checkSqs))
+            || (Piece == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
+            continue;
+
         Bitboard bb = pos.piece_attacks<Piece>(from) & checkSqs;
         SERIALIZE_MOVES(bb);
     }
     return mlist;
   }
 
-  MoveStack* generate_piece_checks_king(const Position& pos, Square from, Bitboard dc,
-                                        Square ksq, MoveStack* mlist) {
-    if (bit_is_set(dc, from))
-    {
-        Bitboard b =   pos.piece_attacks<KING>(from)
-                     & pos.empty_squares()
-                     & ~QueenPseudoAttacks[ksq];
-        SERIALIZE_MOVES(b);
-    }
-    return mlist;
-  }
-
-
   template<Color Us, Rank TRANK_8, Bitboard TRank3BB, SquareDelta TDELTA_N>
-  MoveStack* do_generate_pawn_blocking_evasions(const Position& pos, Bitboard not_pinned,
+  MoveStack* generate_pawn_blocking_evasions(const Position& pos, Bitboard pinned,
-                                                Bitboard blockSquares, MoveStack* mlist) {
+                                             Bitboard blockSquares, MoveStack* mlist) {
     Square to;
 
-    // Find non-pinned pawns
+    // Find non-pinned pawns and push them one square
-    Bitboard b1 = pos.pawns(Us) & not_pinned;
+    Bitboard b1 = move_pawns<Us, DELTA_N>(pos.pawns(Us) & ~pinned);
 
-    // Single pawn pushes. We don't have to AND with empty squares here,
+    // We don't have to AND with empty squares here,
     // because the blocking squares will always be empty.
-    Bitboard b2 = (Us == WHITE ? b1 << 8 : b1 >> 8) & blockSquares;
+    Bitboard b2 = b1 & blockSquares;
     while (b2)
     {
         to = pop_1st_bit(&b2);
@@ -863,8 +859,8 @@ namespace {
     }
 
     // Double pawn pushes
-    b2 = (Us == WHITE ? b1 << 8 : b1 >> 8) & pos.empty_squares() & TRank3BB;
+    b2 = b1 & pos.empty_squares() & TRank3BB;
-    b2 = (Us == WHITE ? b2 << 8 : b2 >> 8) & blockSquares;;
+    b2 = move_pawns<Us, DELTA_N>(b2) & blockSquares;
     while (b2)
     {
         to = pop_1st_bit(&b2);
@@ -878,70 +874,59 @@ namespace {
     return mlist;
   }
 
-
+  template<CastlingSide Side>
   MoveStack* generate_castle_moves(const Position& pos, MoveStack* mlist) {
 
     Color us = pos.side_to_move();
 
-    if (pos.can_castle(us))
+    if (  (Side == KING_SIDE && pos.can_castle_kingside(us))
+        ||(Side == QUEEN_SIDE && pos.can_castle_queenside(us)))
     {
         Color them = opposite_color(us);
         Square ksq = pos.king_square(us);
 
-        assert(pos.piece_on(ksq) == king_of_color(us));
+        assert(pos.piece_on(ksq) == piece_of_color_and_type(us, KING));
 
-        if (pos.can_castle_kingside(us))
+        Square rsq = (Side == KING_SIDE ? pos.initial_kr_square(us) : pos.initial_qr_square(us));
-        {
+        Square s1 = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
-            Square rsq = pos.initial_kr_square(us);
+        Square s2 = relative_square(us, Side == KING_SIDE ? SQ_F1 : SQ_D1);
-            Square g1 = relative_square(us, SQ_G1);
+        Square s;
-            Square f1 = relative_square(us, SQ_F1);
+        bool illegal = false;
-            Square s;
-            bool illegal = false;
 
-            assert(pos.piece_on(rsq) == rook_of_color(us));
+        assert(pos.piece_on(rsq) == piece_of_color_and_type(us, ROOK));
 
-            for (s = Min(ksq, g1); s <= Max(ksq, g1); s++)
+        // It is a bit complicated to correctly handle Chess960
-                if (  (s != ksq && s != rsq && pos.square_is_occupied(s))
+        for (s = Min(ksq, s1); s <= Max(ksq, s1); s++)
-                    || pos.square_is_attacked(s, them))
+            if (  (s != ksq && s != rsq && pos.square_is_occupied(s))
-                    illegal = true;
+                || pos.square_is_attacked(s, them))
+                illegal = true;
 
-            for (s = Min(rsq, f1); s <= Max(rsq, f1); s++)
+        for (s = Min(rsq, s2); s <= Max(rsq, s2); s++)
-                if (s != ksq && s != rsq && pos.square_is_occupied(s))
+            if (s != ksq && s != rsq && pos.square_is_occupied(s))
-                    illegal = true;
+                illegal = true;
 
-            if (!illegal)
+        if (   Side == QUEEN_SIDE
-                (*mlist++).move = make_castle_move(ksq, rsq);
+            && square_file(rsq) == FILE_B
-      }
+            && (   pos.piece_on(relative_square(us, SQ_A1)) == piece_of_color_and_type(them, ROOK)
-
+                || pos.piece_on(relative_square(us, SQ_A1)) == piece_of_color_and_type(them, QUEEN)))
-      if (pos.can_castle_queenside(us))
-      {
-          Square rsq = pos.initial_qr_square(us);
-          Square c1 = relative_square(us, SQ_C1);
-          Square d1 = relative_square(us, SQ_D1);
-          Square s;
-          bool illegal = false;
-
-          assert(pos.piece_on(rsq) == rook_of_color(us));
-
-          for (s = Min(ksq, c1); s <= Max(ksq, c1); s++)
-              if (  (s != ksq && s != rsq && pos.square_is_occupied(s))
-                  || pos.square_is_attacked(s, them))
-                  illegal = true;
-
-          for (s = Min(rsq, d1); s <= Max(rsq, d1); s++)
-              if (s != ksq && s != rsq && pos.square_is_occupied(s))
-                  illegal = true;
-
-        if (   square_file(rsq) == FILE_B
-            && (   pos.piece_on(relative_square(us, SQ_A1)) == rook_of_color(them)
-                || pos.piece_on(relative_square(us, SQ_A1)) == queen_of_color(them)))
             illegal = true;
 
         if (!illegal)
             (*mlist++).move = make_castle_move(ksq, rsq);
-      }
     }
     return mlist;
   }
 
+  bool castling_is_check(const Position& pos, CastlingSide side) {
+
+    // After castling opponent king is attacked by the castled rook?
+    File rookFile = (side == QUEEN_SIDE ? FILE_D : FILE_F);
+    Color us = pos.side_to_move();
+    Square ksq = pos.king_square(us);
+    Bitboard occ = pos.occupied_squares();
+
+    clear_bit(&occ, ksq); // Remove our king from the board
+    Square rsq = make_square(rookFile, square_rank(ksq));
+    return bit_is_set(rook_attacks_bb(rsq, occ), pos.king_square(opposite_color(us)));
+  }
 }

src/movegen.h

@@ -32,12 +32,12 @@
 //// Prototypes
 ////
 
-extern int generate_captures(const Position &pos, MoveStack *mlist);
+extern int generate_captures(const Position& pos, MoveStack* mlist);
-extern int generate_noncaptures(const Position &pos, MoveStack *mlist);
+extern int generate_noncaptures(const Position& pos, MoveStack* mlist);
-extern int generate_checks(const Position &pos, MoveStack *mlist, Bitboard dc);
+extern int generate_non_capture_checks(const Position& pos, MoveStack* mlist, Bitboard dc);
-extern int generate_evasions(const Position &pos, MoveStack *mlist);
+extern int generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pinned);
-extern int generate_legal_moves(const Position &pos, MoveStack *mlist);
+extern int generate_legal_moves(const Position& pos, MoveStack* mlist);
-extern bool move_is_legal(const Position &pos, const Move m, Bitboard pinned);
+extern bool move_is_legal(const Position& pos, const Move m, Bitboard pinned);
 
 
 #endif // !defined(MOVEGEN_H_INCLUDED)

src/movepick.cpp

@@ -23,9 +23,11 @@
 //// Includes
 ////
 
+#include <algorithm>
 #include <cassert>
 
 #include "history.h"
+#include "evaluate.h"
 #include "movegen.h"
 #include "movepick.h"
 #include "search.h"
@@ -49,7 +51,6 @@ namespace {
 }
 
 
-
 ////
 //// Functions
 ////
@@ -62,29 +63,31 @@ namespace {
 /// search captures, promotions and some checks) and about how important good
 /// move ordering is at the current node.
 
-MovePicker::MovePicker(const Position& p, bool pvnode, Move ttm, Move mk,
+MovePicker::MovePicker(const Position& p, bool pv, Move ttm,
-                       Move k1, Move k2, Depth d) : pos(p) {
+                       const SearchStack& ss, Depth d) : pos(p) {
-  pvNode = pvnode;
+  pvNode = pv;
   ttMove = ttm;
-  mateKiller = (mk == ttm)? MOVE_NONE : mk;
+  mateKiller = (ss.mateKiller == ttm)? MOVE_NONE : ss.mateKiller;
-  killer1 = k1;
+  killer1 = ss.killers[0];
-  killer2 = k2;
+  killer2 = ss.killers[1];
   depth = d;
   movesPicked = 0;
   numOfMoves = 0;
   numOfBadCaptures = 0;
-  dc = p.discovered_check_candidates(p.side_to_move());
 
   if (p.is_check())
-    phaseIndex = EvasionsPhaseIndex;
+      phaseIndex = EvasionsPhaseIndex;
   else if (depth > Depth(0))
-    phaseIndex = MainSearchPhaseIndex;
+      phaseIndex = MainSearchPhaseIndex;
   else if (depth == Depth(0))
-    phaseIndex = QsearchWithChecksPhaseIndex;
+      phaseIndex = QsearchWithChecksPhaseIndex;
   else
-    phaseIndex = QsearchWithoutChecksPhaseIndex;
+      phaseIndex = QsearchWithoutChecksPhaseIndex;
 
-  pinned = p.pinned_pieces(p.side_to_move());
+  Color us = pos.side_to_move();
+
+  dc = p.discovered_check_candidates(us);
+  pinned = p.pinned_pieces(us);
 
   finished = false;
 }
@@ -128,40 +131,46 @@ Move MovePicker::get_next_move() {
             assert(move_is_ok(mateKiller));
             if (move_is_legal(pos, mateKiller, pinned))
                 return mateKiller;
-       }
+        }
-       break;
+        break;
 
     case PH_GOOD_CAPTURES:
         numOfMoves = generate_captures(pos, moves);
         score_captures();
+        std::sort(moves, moves + numOfMoves);
         movesPicked = 0;
         break;
 
     case PH_BAD_CAPTURES:
-        badCapturesPicked = 0;
+        // It's probably a good idea to use SEE move ordering here. FIXME
+        movesPicked = 0;
         break;
 
     case PH_NONCAPTURES:
         numOfMoves = generate_noncaptures(pos, moves);
         score_noncaptures();
+        std::sort(moves, moves + numOfMoves);
         movesPicked = 0;
         break;
 
     case PH_EVASIONS:
         assert(pos.is_check());
-        numOfMoves = generate_evasions(pos, moves);
+        numOfMoves = generate_evasions(pos, moves, pinned);
         score_evasions();
+        std::sort(moves, moves + numOfMoves);
         movesPicked = 0;
         break;
 
     case PH_QCAPTURES:
         numOfMoves = generate_captures(pos, moves);
         score_qcaptures();
+        std::sort(moves, moves + numOfMoves);
         movesPicked = 0;
         break;
 
     case PH_QCHECKS:
-        numOfMoves = generate_checks(pos, moves, dc);
+        // Perhaps we should order moves move here?  FIXME
+        numOfMoves = generate_non_capture_checks(pos, moves, dc);
         movesPicked = 0;
         break;
 
@@ -211,6 +220,8 @@ void MovePicker::score_captures() {
   // where it is possible to recapture with the hanging piece). Exchanging
   // big pieces before capturing a hanging piece probably helps to reduce
   // the subtree size.
+  // While scoring captures it moves all captures with negative SEE values
+  // to the badCaptures[] array.
   Move m;
   int seeValue;
 
@@ -225,8 +236,15 @@ void MovePicker::score_captures() {
           else
               moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
                               -int(pos.type_of_piece_on(move_from(m)));
-      } else
+      }
+      else
+      {
+          // Losing capture, move it to the badCaptures[] array
+          assert(numOfBadCaptures < 63);
           moves[i].score = seeValue;
+          badCaptures[numOfBadCaptures++] = moves[i];
+          moves[i--] = moves[--numOfMoves];
+      }
   }
 }
 
@@ -248,10 +266,11 @@ void MovePicker::score_noncaptures() {
       else
           hs = H.move_ordering_score(pos.piece_on(move_from(m)), m);
 
-      // Ensure moves in history are always sorted as first
+      // Ensure history is always preferred to pst
       if (hs > 0)
           hs += 1000;
 
+      // pst based scoring
       moves[i].score = hs + pos.mg_pst_delta(m);
   }
 }
@@ -270,7 +289,6 @@ void MovePicker::score_evasions() {
       } else
           moves[i].score = H.move_ordering_score(pos.piece_on(move_from(m)), m);
   }
-  // FIXME try psqt also here
 }
 
 void MovePicker::score_qcaptures() {
@@ -288,121 +306,41 @@ void MovePicker::score_qcaptures() {
 }
 
 
-/// find_best_index() loops across the moves and returns index of
-/// the highest scored one.
-
-int MovePicker::find_best_index() {
-
-  int bestScore = -10000000, bestIndex = -1;
-
-  for (int i = movesPicked; i < numOfMoves; i++)
-      if (moves[i].score > bestScore)
-      {
-          bestIndex = i;
-          bestScore = moves[i].score;
-      }
-  return bestIndex;
-}
-
-
 /// MovePicker::pick_move_from_list() picks the move with the biggest score
 /// from a list of generated moves (moves[] or badCaptures[], depending on
 /// the current move generation phase).  It takes care not to return the
 /// transposition table move if that has already been serched previously.
-/// While picking captures in the PH_GOOD_CAPTURES phase (i.e. while picking
-/// non-losing captures in the main search), it moves all captures with
-/// negative SEE values to the badCaptures[] array.
 
 Move MovePicker::pick_move_from_list() {
 
-  int bestIndex;
+  assert(movesPicked >= 0);
-  Move move;
+  assert(!pos.is_check() || PhaseTable[phaseIndex] == PH_EVASIONS || PhaseTable[phaseIndex] == PH_STOP);
+  assert( pos.is_check() || PhaseTable[phaseIndex] != PH_EVASIONS);
 
   switch (PhaseTable[phaseIndex]) {
+
   case PH_GOOD_CAPTURES:
-      assert(!pos.is_check());
-      assert(movesPicked >= 0);
-
-      while (movesPicked < numOfMoves)
-      {
-          int bestScore = -10000000;
-          bestIndex = -1;
-          for (int i = movesPicked; i < numOfMoves; i++)
-          {
-              if (moves[i].score < 0)
-              {
-                  // Losing capture, move it to the badCaptures[] array
-                  assert(numOfBadCaptures < 63);
-                  badCaptures[numOfBadCaptures++] = moves[i];
-                  moves[i--] = moves[--numOfMoves];
-              }
-              else if (moves[i].score > bestScore)
-              {
-                  bestIndex = i;
-                  bestScore = moves[i].score;
-              }
-          }
-          if (bestIndex != -1) // Found a good capture
-          {
-              move = moves[bestIndex].move;
-              moves[bestIndex] = moves[movesPicked++];
-              if (   move != ttMove
-                  && move != mateKiller
-                  && pos.pl_move_is_legal(move, pinned))
-                  return move;
-          }
-      }
-      break;
-
   case PH_NONCAPTURES:
-      assert(!pos.is_check());
-      assert(movesPicked >= 0);
-
       while (movesPicked < numOfMoves)
       {
-          // If this is a PV node or we have only picked a few moves, scan
+          Move move = moves[movesPicked++].move;
-          // the entire move list for the best move.  If many moves have already
+          if (   move != ttMove
-          // been searched and it is not a PV node, we are probably failing low
+              && move != mateKiller
-          // anyway, so we just pick the first move from the list.
+              && pos.pl_move_is_legal(move, pinned))
-          bestIndex = (pvNode || movesPicked < 12) ? find_best_index() : movesPicked;
+              return move;
-
-          if (bestIndex != -1)
-          {
-              move = moves[bestIndex].move;
-              moves[bestIndex] = moves[movesPicked++];
-              if (   move != ttMove
-                  && move != mateKiller
-                  && pos.pl_move_is_legal(move, pinned))
-                  return move;
-          }
       }
       break;
 
   case PH_EVASIONS:
-      assert(pos.is_check());
+      if (movesPicked < numOfMoves)
-      assert(movesPicked >= 0);
+          return moves[movesPicked++].move;
 
-      while (movesPicked < numOfMoves)
+      break;
-      {
-          bestIndex = find_best_index();
-
-          if (bestIndex != -1)
-          {
-              move = moves[bestIndex].move;
-              moves[bestIndex] = moves[movesPicked++];
-              return move;
-          }
-    }
-    break;
 
   case PH_BAD_CAPTURES:
-      assert(!pos.is_check());
+      while (movesPicked < numOfBadCaptures)
-      assert(badCapturesPicked >= 0);
-      // It's probably a good idea to use SEE move ordering here, instead
-      // of just picking the first move.  FIXME
-      while (badCapturesPicked < numOfBadCaptures)
       {
-          move = badCaptures[badCapturesPicked++].move;
+          Move move = badCaptures[movesPicked++].move;
           if (   move != ttMove
               && move != mateKiller
               && pos.pl_move_is_legal(move, pinned))
@@ -411,34 +349,13 @@ Move MovePicker::pick_move_from_list() {
       break;
 
   case PH_QCAPTURES:
-      assert(!pos.is_check());
-      assert(movesPicked >= 0);
-      while (movesPicked < numOfMoves)
-      {
-          bestIndex = (movesPicked < 4 ? find_best_index() : movesPicked);
-
-          if (bestIndex != -1)
-          {
-              move = moves[bestIndex].move;
-              moves[bestIndex] = moves[movesPicked++];
-              // Remember to change the line below if we decide to hash the qsearch!
-              // Maybe also postpone the legality check until after futility pruning?
-              if (/* move != ttMove && */ pos.pl_move_is_legal(move, pinned))
-                  return move;
-          }
-      }
-      break;
-
   case PH_QCHECKS:
-      assert(!pos.is_check());
-      assert(movesPicked >= 0);
-      // Perhaps we should do something better than just picking the first
-      // move here?  FIXME
       while (movesPicked < numOfMoves)
       {
-          move = moves[movesPicked++].move;
+          Move move = moves[movesPicked++].move;
-          // Remember to change the line below if we decide to hash the qsearch!
+          // Maybe postpone the legality check until after futility pruning?
-          if (/* move != ttMove && */ pos.pl_move_is_legal(move, pinned))
+          if (   move != ttMove
+              && pos.pl_move_is_legal(move, pinned))
               return move;
       }
       break;
@@ -450,19 +367,10 @@ Move MovePicker::pick_move_from_list() {
 }
 
 
-/// MovePicker::current_move_type() returns the type of the just
-/// picked next move. It can be used in search to further differentiate
-/// according to the current move type: capture, non capture, escape, etc.
-MovePicker::MovegenPhase MovePicker::current_move_type() const {
-
-  return PhaseTable[phaseIndex];
-}
-
-
 /// MovePicker::init_phase_table() initializes the PhaseTable[],
 /// MainSearchPhaseIndex, EvasionPhaseIndex, QsearchWithChecksPhaseIndex
-/// and QsearchWithoutChecksPhaseIndex variables. It is only called once
+/// and QsearchWithoutChecksPhaseIndex. It is only called once during
-/// during program startup, and never again while the program is running.
+/// program startup, and never again while the program is running.
 
 void MovePicker::init_phase_table() {
 
@@ -487,12 +395,14 @@ void MovePicker::init_phase_table() {
 
   // Quiescence search with checks
   QsearchWithChecksPhaseIndex = i - 1;
+  PhaseTable[i++] = PH_TT_MOVE;
   PhaseTable[i++] = PH_QCAPTURES;
   PhaseTable[i++] = PH_QCHECKS;
   PhaseTable[i++] = PH_STOP;
 
   // Quiescence search without checks
   QsearchWithoutChecksPhaseIndex = i - 1;
+  PhaseTable[i++] = PH_TT_MOVE;
   PhaseTable[i++] = PH_QCAPTURES;
   PhaseTable[i++] = PH_STOP;
 }

src/movepick.h

@@ -34,6 +34,9 @@
 //// Types
 ////
 
+struct EvalInfo;
+struct SearchStack;
+
 /// MovePicker is a class which is used to pick one legal move at a time from
 /// the current position.  It is initialized with a Position object and a few
 /// moves we have reason to believe are good.  The most important method is
@@ -44,6 +47,8 @@
 
 class MovePicker {
 
+  MovePicker& operator=(const MovePicker&); // Silence a warning under MSVC
+
 public:
 
   enum MovegenPhase {
@@ -60,12 +65,11 @@ public:
     PH_STOP
   };
 
-  MovePicker(const Position& p, bool pvnode, Move ttm, Move mk, Move k1, Move k2, Depth d);
+  MovePicker(const Position& p, bool pvnode, Move ttm, const SearchStack& ss, Depth d);
   Move get_next_move();
   Move get_next_move(Lock &lock);
   int number_of_moves() const;
   int current_move_score() const;
-  MovegenPhase current_move_type() const;
   Bitboard discovered_check_candidates() const;
 
   static void init_phase_table();
@@ -76,7 +80,6 @@ private:
   void score_evasions();
   void score_qcaptures();
   Move pick_move_from_list();
-  int find_best_index();
 
   const Position& pos;
   Move ttMove, mateKiller, killer1, killer2;
@@ -86,7 +89,7 @@ private:
   Depth depth;
   int phaseIndex;
   int numOfMoves, numOfBadCaptures;
-  int movesPicked, badCapturesPicked;
+  int movesPicked;
   bool finished;
 };
 
@@ -101,7 +104,6 @@ private:
 /// a single reply to check.
 
 inline int MovePicker::number_of_moves() const {
-
   return numOfMoves;
 }
 

src/pawns.cpp

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -26,6 +26,7 @@
 #include <cstring>
 
 #include "pawns.h"
+#include "position.h"
 
 
 ////
@@ -72,13 +73,13 @@ namespace {
     Value(32), Value(32), Value(32), Value(28)
   };
 
-  // Pawn chain membership bonus by file, middle game. 
+  // Pawn chain membership bonus by file, middle game.
   const Value ChainMidgameBonus[8] = {
     Value(14), Value(16), Value(17), Value(18),
     Value(18), Value(17), Value(16), Value(14)
   };
 
-  // Pawn chain membership bonus by file, endgame. 
+  // Pawn chain membership bonus by file, endgame.
   const Value ChainEndgameBonus[8] = {
     Value(16), Value(16), Value(16), Value(16),
     Value(16), Value(16), Value(16), Value(16)
@@ -86,50 +87,45 @@ namespace {
 
   // Candidate passed pawn bonus by rank, middle game.
   const Value CandidateMidgameBonus[8] = {
-    Value(0), Value(12), Value(12), Value(20),
+    Value( 0), Value(12), Value(12), Value(20),
-    Value(40), Value(90), Value(0), Value(0)
+    Value(40), Value(90), Value( 0), Value( 0)
   };
 
   // Candidate passed pawn bonus by rank, endgame.
   const Value CandidateEndgameBonus[8] = {
-    Value(0), Value(24), Value(24), Value(40),
+    Value( 0), Value(24), Value(24), Value(40),
-    Value(80), Value(180), Value(0), Value(0)
+    Value(80), Value(180), Value(0), Value( 0)
   };
 
-  // Evaluate pawn storms?
-  const bool EvaluatePawnStorms = true;
-
   // Pawn storm tables for positions with opposite castling:
   const int QStormTable[64] = {
-    0, 0, 0, 0, 0, 0, 0, 0,
+    0,  0,  0,  0, 0, 0, 0, 0,
-    -22, -22, -22, -13, -4, 0, 0, 0,
+  -22,-22,-22,-13,-4, 0, 0, 0,
-    -4, -9, -9, -9, -4, 0, 0, 0,
+   -4, -9, -9, -9,-4, 0, 0, 0,
     9, 18, 22, 18, 9, 0, 0, 0,
-    22, 31, 31, 22, 0, 0, 0, 0,
+   22, 31, 31, 22, 0, 0, 0, 0,
-    31, 40, 40, 31, 0, 0, 0, 0,
+   31, 40, 40, 31, 0, 0, 0, 0,
-    31, 40, 40, 31, 0, 0, 0, 0,
+   31, 40, 40, 31, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0
+    0,  0,  0,  0, 0, 0, 0, 0
   };
-  
+
   const int KStormTable[64] = {
-    0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0,  0,  0,  0,  0,
-    0, 0, 0, -4, -13, -22, -27, -27,
+    0, 0, 0,-4,-13,-22,-27,-27,
-    0, 0, 0, -4, -9, -13, -18, -18,
+    0, 0, 0,-4, -9,-13,-18,-18,
-    0, 0, 0, 0, 9, 9, 9, 9,
+    0, 0, 0, 0,  9,  9,  9,  9,
-    0, 0, 0, 0, 9, 18, 27, 27,
+    0, 0, 0, 0,  9, 18, 27, 27,
-    0, 0, 0, 0, 9, 27, 40, 36,
+    0, 0, 0, 0,  9, 27, 40, 36,
-    0, 0, 0, 0, 0, 31, 40, 31,
+    0, 0, 0, 0,  0, 31, 40, 31,
-    0, 0, 0, 0, 0, 0, 0, 0
+    0, 0, 0, 0,  0,  0,  0,  0
   };
 
-  // Pawn storm open file bonuses by file:
+  // Pawn storm open file bonuses by file
-  const int KStormOpenFileBonus[8] = {
+  const int16_t KStormOpenFileBonus[8] = { 45, 45, 30, 0, 0, 0, 0, 0 };
-    45, 45, 30, 0, 0, 0, 0, 0
+  const int16_t QStormOpenFileBonus[8] = { 0, 0, 0, 0, 0, 30, 45, 30 };
-  };
 
-  const int QStormOpenFileBonus[8] = {
+  // Pawn storm lever bonuses by file
-    0, 0, 0, 0, 0, 30, 45, 30
+  const int StormLeverBonus[8] = { 20, 20, 10, 0, 0, 10, 20, 20 };
-  };
 
 }
 
@@ -141,14 +137,16 @@ namespace {
 /// Constructor
 
 PawnInfoTable::PawnInfoTable(unsigned numOfEntries) {
+
   size = numOfEntries;
   entries = new PawnInfo[size];
-  if(entries == NULL) {
+  if (entries == NULL)
-    std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
+  {
-              << " bytes for pawn hash table." << std::endl;
+      std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
-    exit(EXIT_FAILURE);
+                << " bytes for pawn hash table." << std::endl;
+      exit(EXIT_FAILURE);
   }
-  this->clear();
+  clear();
 }
 
 
@@ -168,220 +166,231 @@ void PawnInfoTable::clear() {
 
 
 /// PawnInfoTable::get_pawn_info() takes a position object as input, computes
-/// a PawnInfo object, and returns a pointer to it.  The result is also 
+/// a PawnInfo object, and returns a pointer to it.  The result is also
 /// stored in a hash table, so we don't have to recompute everything when
 /// the same pawn structure occurs again.
 
 PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
+
   assert(pos.is_ok());
 
   Key key = pos.get_pawn_key();
   int index = int(key & (size - 1));
   PawnInfo *pi = entries + index;
 
-  // If pi->key matches the position's pawn hash key, it means that we 
+  // If pi->key matches the position's pawn hash key, it means that we
   // have analysed this pawn structure before, and we can simply return the
-  // information we found the last time instead of recomputing it:
+  // information we found the last time instead of recomputing it
-  if(pi->key == key)
+  if (pi->key == key)
-    return pi;
+      return pi;
 
-  // Clear the PawnInfo object, and set the key:
+  // Clear the PawnInfo object, and set the key
   pi->clear();
   pi->key = key;
 
   Value mgValue[2] = {Value(0), Value(0)};
   Value egValue[2] = {Value(0), Value(0)};
 
-  // Loop through the pawns for both colors:
+  // Loop through the pawns for both colors
-  for(Color us = WHITE; us <= BLACK; us++) {
+  for (Color us = WHITE; us <= BLACK; us++)
+  {
     Color them = opposite_color(us);
     Bitboard ourPawns = pos.pawns(us);
     Bitboard theirPawns = pos.pawns(them);
     Bitboard pawns = ourPawns;
+    int bonus;
 
-    // Initialize pawn storm scores by giving bonuses for open files:
+    // Initialize pawn storm scores by giving bonuses for open files
-    if(EvaluatePawnStorms)
+    for (File f = FILE_A; f <= FILE_H; f++)
-      for(File f = FILE_A; f <= FILE_H; f++)
+        if (pos.file_is_half_open(us, f))
-        if(pos.file_is_half_open(us, f)) {
+        {
-          pi->ksStormValue[us] += KStormOpenFileBonus[f];
+            pi->ksStormValue[us] += KStormOpenFileBonus[f];
-          pi->qsStormValue[us] += QStormOpenFileBonus[f];
+            pi->qsStormValue[us] += QStormOpenFileBonus[f];
         }
 
-    // Loop through all pawns of the current color and score each pawn:
+    // Loop through all pawns of the current color and score each pawn
-    while(pawns) {
+    while (pawns)
-      Square s = pop_1st_bit(&pawns);
+    {
-      File f = square_file(s);
+        bool passed, doubled, isolated, backward, chain, candidate;
-      Rank r = square_rank(s);
+        Square s = pop_1st_bit(&pawns);
-      bool passed, doubled, isolated, backward, chain, candidate;
+        File f = square_file(s);
-      int bonus;
+        Rank r = square_rank(s);
 
-      assert(pos.piece_on(s) == pawn_of_color(us));
+        assert(pos.piece_on(s) == piece_of_color_and_type(us, PAWN));
 
-      // The file containing the pawn is not half open:
+        // The file containing the pawn is not half open
-      pi->halfOpenFiles[us] &= ~(1 << f);
+        pi->halfOpenFiles[us] &= ~(1 << f);
 
-      // Passed, isolated or doubled pawn?
+        // Passed, isolated or doubled pawn?
-      passed = pos.pawn_is_passed(us, s);
+        passed = pos.pawn_is_passed(us, s);
-      isolated = pos.pawn_is_isolated(us, s);
+        isolated = pos.pawn_is_isolated(us, s);
-      doubled = pos.pawn_is_doubled(us, s);
+        doubled = pos.pawn_is_doubled(us, s);
 
-      if(EvaluatePawnStorms) {
         // We calculate kingside and queenside pawn storm
-        // scores for both colors.  These are used when evaluating
+        // scores for both colors. These are used when evaluating
         // middle game positions with opposite side castling.
         //
         // Each pawn is given a base score given by a piece square table
-        // (KStormTable[] or QStormTable[]).  This score is increased if
+        // (KStormTable[] or QStormTable[]). Pawns which seem to have good
-        // there are enemy pawns on adjacent files in front of the pawn.
+        // chances of creating an open file by exchanging itself against an
-        // This is because we want to be able to open files against the
+        // enemy pawn on an adjacent file gets an additional bonus.
-        // enemy king, and to avoid blocking the pawn structure (e.g. white
+
-        // pawns on h6, g5, black pawns on h7, g6, f7).
+        // Kingside pawn storms
-        
-        // Kingside pawn storms:
         bonus = KStormTable[relative_square(us, s)];
-        if(bonus > 0 && outpost_mask(us, s) & theirPawns) {
+        if (f >= FILE_F)
-          switch(f) {
+        {
-
+            Bitboard b = outpost_mask(us, s) & theirPawns & (FileFBB | FileGBB | FileHBB);
-          case FILE_F:
+            while (b)
-            bonus += bonus / 4;
+            {
-            break;
+                Square s2 = pop_1st_bit(&b);
-
+                if (!(theirPawns & neighboring_files_bb(s2) & rank_bb(s2)))
-          case FILE_G:
+                {
-            bonus += bonus / 2 + bonus / 4;
+                    // The enemy pawn has no pawn beside itself, which makes it
-            break;
+                    // particularly vulnerable. Big bonus, especially against a
-
+                    // weakness on the rook file.
-          case FILE_H:
+                    if (square_file(s2) == FILE_H)
-            bonus += bonus / 2;
+                        bonus += 4*StormLeverBonus[f] - 8*square_distance(s, s2);
-            break;
+                    else
-
+                        bonus += 2*StormLeverBonus[f] - 4*square_distance(s, s2);
-          default:
+                } else
-            break;
+                    // There is at least one enemy pawn beside the enemy pawn we look
-          }
+                    // at, which means that the pawn has somewhat better chances of
+                    // defending itself by advancing. Smaller bonus.
+                    bonus += StormLeverBonus[f] - 2*square_distance(s, s2);
+            }
         }
         pi->ksStormValue[us] += bonus;
 
-        // Queenside pawn storms:
+        // Queenside pawn storms
         bonus = QStormTable[relative_square(us, s)];
-        if(bonus > 0 && passed_pawn_mask(us, s) & theirPawns) {
+        if (f <= FILE_C)
-          switch(f) {
+        {
-
+            Bitboard b = outpost_mask(us, s) & theirPawns & (FileABB | FileBBB | FileCBB);
-          case FILE_A:
+            while (b)
-            bonus += bonus / 2;
+            {
-            break;
+                Square s2 = pop_1st_bit(&b);
-
+                if (!(theirPawns & neighboring_files_bb(s2) & rank_bb(s2)))
-          case FILE_B:
+                {
-            bonus += bonus / 2 + bonus / 4;
+                    // The enemy pawn has no pawn beside itself, which makes it
-            break;
+                    // particularly vulnerable. Big bonus, especially against a
-
+                    // weakness on the rook file.
-          case FILE_C:
+                    if (square_file(s2) == FILE_A)
-            bonus += bonus / 2;
+                        bonus += 4*StormLeverBonus[f] - 16*square_distance(s, s2);
-            break;
+                    else
-
+                        bonus += 2*StormLeverBonus[f] - 8*square_distance(s, s2);
-          default:
+                } else
-            break;
+                    // There is at least one enemy pawn beside the enemy pawn we look
-          }
+                    // at, which means that the pawn has somewhat better chances of
+                    // defending itself by advancing. Smaller bonus.
+                    bonus += StormLeverBonus[f] - 4*square_distance(s, s2);
+            }
         }
         pi->qsStormValue[us] += bonus;
-      }
-      
-      // Member of a pawn chain?  We could speed up the test a little by 
-      // introducing an array of masks indexed by color and square for doing
-      // the test, but because everything is hashed, it probably won't make
-      // any noticable difference.
-      chain = (us == WHITE)?
-        (ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r-1))) :
-        (ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r+1)));
 
+        // Member of a pawn chain (but not the backward one)? We could speed up
+        // the test a little by introducing an array of masks indexed by color
+        // and square for doing the test, but because everything is hashed,
+        // it probably won't make any noticable difference.
+        chain =  ourPawns
+               & neighboring_files_bb(f)
+               & (rank_bb(r) | rank_bb(r - (us == WHITE ? 1 : -1)));
 
-      // Test for backward pawn.
+        // Test for backward pawn
-
+        //
-      // If the pawn is isolated, passed, or member of a pawn chain, it cannot
+        // If the pawn is passed, isolated, or member of a pawn chain
-      // be backward:
+        // it cannot be backward. If can capture an enemy pawn or if
-      if(passed || isolated || chain)
+        // there are friendly pawns behind on neighboring files it cannot
-        backward = false;
+        // be backward either.
-      // If the pawn can capture an enemy pawn, it's not backward:
+        if (   passed
-      else if(pos.pawn_attacks(us, s) & theirPawns)
+            || isolated
-        backward = false;
+            || chain
-      // Check for friendly pawns behind on neighboring files:
+            || (pos.pawn_attacks(us, s) & theirPawns)
-      else if(ourPawns & in_front_bb(them, r) & neighboring_files_bb(f))
+            || (ourPawns & behind_bb(us, r) & neighboring_files_bb(f)))
-        backward = false;
+            backward = false;
-      else {
+        else
-        // We now know that there is no friendly pawns beside or behind this
+        {
-        // pawn on neighboring files.  We now check whether the pawn is
+            // We now know that there are no friendly pawns beside or behind this
-        // backward by looking in the forward direction on the neighboring
+            // pawn on neighboring files. We now check whether the pawn is
-        // files, and seeing whether we meet a friendly or an enemy pawn first.
+            // backward by looking in the forward direction on the neighboring
-        Bitboard b;
+            // files, and seeing whether we meet a friendly or an enemy pawn first.
-        if(us == WHITE) {
+            Bitboard b;
-          for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b<<=8);
+            if (us == WHITE)
-          backward = (b | (b << 8)) & theirPawns;
+            {
+                for (b = pos.pawn_attacks(us, s); !(b & (ourPawns | theirPawns)); b <<= 8);
+                backward = (b | (b << 8)) & theirPawns;
+            }
+            else
+            {
+                for (b = pos.pawn_attacks(us, s); !(b & (ourPawns | theirPawns)); b >>= 8);
+                backward = (b | (b >> 8)) & theirPawns;
+            }
         }
-        else {
+
-          for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b>>=8);
+        // Test for candidate passed pawn
-          backward = (b | (b >> 8)) & theirPawns;
+        candidate =    !passed
+                     && pos.file_is_half_open(them, f)
+                     && (  count_1s_max_15(neighboring_files_bb(f) & (behind_bb(us, r) | rank_bb(r)) & ourPawns)
+                         - count_1s_max_15(neighboring_files_bb(f) & in_front_bb(us, r)              & theirPawns)
+                         >= 0);
+
+        // In order to prevent doubled passed pawns from receiving a too big
+        // bonus, only the frontmost passed pawn on each file is considered as
+        // a true passed pawn.
+        if (passed && (ourPawns & squares_in_front_of(us, s)))
+        {
+            // candidate = true;
+            passed = false;
         }
-      }
 
-      // Test for candidate passed pawn.
+        // Score this pawn
-      candidate =
+        Value mv = Value(0), ev = Value(0);
-        (!passed && pos.file_is_half_open(them, f) &&
+        if (isolated)
-         count_1s_max_15(neighboring_files_bb(f)
+        {
-                         & (in_front_bb(them, r) | rank_bb(r))
+            mv -= IsolatedPawnMidgamePenalty[f];
-                         & ourPawns)
+            ev -= IsolatedPawnEndgamePenalty[f];
-         - count_1s_max_15(neighboring_files_bb(f) & in_front_bb(us, r)
+            if (pos.file_is_half_open(them, f))
-                           & theirPawns)
+            {
-         >= 0);
+                mv -= IsolatedPawnMidgamePenalty[f] / 2;
-
+                ev -= IsolatedPawnEndgamePenalty[f] / 2;
-      // In order to prevent doubled passed pawns from receiving a too big
+            }
-      // bonus, only the frontmost passed pawn on each file is considered as
-      // a true passed pawn.
-      if(passed && (ourPawns & squares_in_front_of(us, s))) {
-        // candidate = true;
-        passed = false;
-      }
-
-      // Score this pawn:
-      Value mv = Value(0), ev = Value(0);
-      if(isolated) {
-        mv -= IsolatedPawnMidgamePenalty[f];
-        ev -= IsolatedPawnEndgamePenalty[f];
-        if(pos.file_is_half_open(them, f)) {
-          mv -= IsolatedPawnMidgamePenalty[f] / 2;
-          ev -= IsolatedPawnEndgamePenalty[f] / 2;
         }
-      }
+        if (doubled)
-      if(doubled)  {
+        {
-        mv -= DoubledPawnMidgamePenalty[f];
+            mv -= DoubledPawnMidgamePenalty[f];
-        ev -= DoubledPawnEndgamePenalty[f];
+            ev -= DoubledPawnEndgamePenalty[f];
-      }
+        }
-      if(backward)  {
+        if (backward)
-        mv -= BackwardPawnMidgamePenalty[f];
+        {
-        ev -= BackwardPawnEndgamePenalty[f];
+            mv -= BackwardPawnMidgamePenalty[f];
-        if(pos.file_is_half_open(them, f)) {
+            ev -= BackwardPawnEndgamePenalty[f];
-          mv -= BackwardPawnMidgamePenalty[f] / 2;
+            if (pos.file_is_half_open(them, f))
-          ev -= BackwardPawnEndgamePenalty[f] / 2;
+            {
+                mv -= BackwardPawnMidgamePenalty[f] / 2;
+                ev -= BackwardPawnEndgamePenalty[f] / 2;
+            }
+        }
+        if (chain)
+        {
+            mv += ChainMidgameBonus[f];
+            ev += ChainEndgameBonus[f];
+        }
+        if (candidate)
+        {
+            mv += CandidateMidgameBonus[relative_rank(us, s)];
+            ev += CandidateEndgameBonus[relative_rank(us, s)];
         }
-      }
-      if(chain) {
-        mv += ChainMidgameBonus[f];
-        ev += ChainEndgameBonus[f];
-      }
-      if(candidate) {
-        mv += CandidateMidgameBonus[relative_rank(us, s)];
-        ev += CandidateEndgameBonus[relative_rank(us, s)];
-      }
 
-      mgValue[us] += mv;
+        mgValue[us] += mv;
-      egValue[us] += ev;
+        egValue[us] += ev;
-        
+
-      // If the pawn is passed, set the square of the pawn in the passedPawns
+        // If the pawn is passed, set the square of the pawn in the passedPawns
-      // bitboard:
+        // bitboard
-      if(passed)
+        if (passed)
-        set_bit(&(pi->passedPawns), s);
+            set_bit(&(pi->passedPawns), s);
-    }
+    } // while(pawns)
-  }
+  } // for(colors)
 
   pi->mgValue = int16_t(mgValue[WHITE] - mgValue[BLACK]);
   pi->egValue = int16_t(egValue[WHITE] - egValue[BLACK]);
-
   return pi;
 }

src/pawns.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -25,19 +25,20 @@
 //// Includes
 ////
 
-#include "position.h"
+#include "bitboard.h"
-
+#include "value.h"
 
 ////
 //// Types
 ////
 
-/// PawnInfo is a class which contains various information about a pawn 
+/// PawnInfo is a class which contains various information about a pawn
 /// structure.  Currently, it only includes a middle game and an end game
 /// pawn structure evaluation, and a bitboard of passed pawns.  We may want
 /// to add further information in the future.  A lookup to the pawn hash table
 /// (performed by calling the get_pawn_info method in a PawnInfoTable object)
 /// returns a pointer to a PawnInfo object.
+class Position;
 
 class PawnInfo {
 
@@ -49,9 +50,9 @@ public:
   Value kingside_storm_value(Color c) const;
   Value queenside_storm_value(Color c) const;
   Bitboard passed_pawns() const;
-  bool file_is_half_open(Color c, File f) const;
+  int file_is_half_open(Color c, File f) const;
-  bool has_open_file_to_left(Color c, File f) const;
+  int has_open_file_to_left(Color c, File f) const;
-  bool has_open_file_to_right(Color c, File f) const;
+  int has_open_file_to_right(Color c, File f) const;
 
 private:
   void clear();
@@ -59,7 +60,7 @@ private:
   Key key;
   Bitboard passedPawns;
   int16_t mgValue, egValue;
-  int8_t ksStormValue[2], qsStormValue[2];
+  int16_t ksStormValue[2], qsStormValue[2];
   uint8_t halfOpenFiles[2];
 };
 
@@ -75,11 +76,11 @@ public:
   PawnInfoTable(unsigned numOfEntries);
   ~PawnInfoTable();
   void clear();
-  PawnInfo *get_pawn_info(const Position &pos);
+  PawnInfo* get_pawn_info(const Position& pos);
 
 private:
   unsigned size;
-  PawnInfo *entries;
+  PawnInfo* entries;
 };
 
 
@@ -107,21 +108,22 @@ inline Value PawnInfo::queenside_storm_value(Color c) const {
   return Value(qsStormValue[c]);
 }
 
-inline bool PawnInfo::file_is_half_open(Color c, File f) const {
+inline int PawnInfo::file_is_half_open(Color c, File f) const {
   return (halfOpenFiles[c] & (1 << int(f)));
 }
 
-inline bool PawnInfo::has_open_file_to_left(Color c, File f) const {
+inline int PawnInfo::has_open_file_to_left(Color c, File f) const {
   return halfOpenFiles[c] & ((1 << int(f)) - 1);
 }
 
-inline bool PawnInfo::has_open_file_to_right(Color c, File f) const {
+inline int PawnInfo::has_open_file_to_right(Color c, File f) const {
   return halfOpenFiles[c] & ~((1 << int(f+1)) - 1);
 }
 
 inline void PawnInfo::clear() {
-  mgValue = egValue = 0;
+
   passedPawns = EmptyBoardBB;
+  mgValue = egValue = 0;
   ksStormValue[WHITE] = ksStormValue[BLACK] = 0;
   qsStormValue[WHITE] = qsStormValue[BLACK] = 0;
   halfOpenFiles[WHITE] = halfOpenFiles[BLACK] = 0xFF;

src/phase.h

@@ -1,34 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
-
-  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.
-  
-  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.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(PHASE_H_INCLUDED)
-#define PHASE_H_INCLUDED
-
-////
-//// Types
-////
-
-enum Phase {
-  PHASE_ENDGAME = 0,
-  PHASE_MIDGAME = 128
-};
-
-
-#endif // !defined(PHASE_H_INCLUDED)

src/piece.cpp

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -22,74 +22,28 @@
 //// Includes
 ////
 
-#include <cstring>
+#include <string>
 
 #include "piece.h"
 
-
+using namespace std;
-////
-//// Constants and variables
-////
-
-const int SlidingArray[18] = {
-  0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0
-};
-
-const SquareDelta Directions[16][16] = {
-  {DELTA_ZERO},
-  {DELTA_NW, DELTA_NE, DELTA_ZERO},
-  {DELTA_SSW, DELTA_SSE, DELTA_SWW, DELTA_SEE,
-   DELTA_NWW, DELTA_NEE, DELTA_NNW, DELTA_NNE, DELTA_ZERO},
-  {DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_ZERO},
-  {DELTA_ZERO},
-  {DELTA_SW, DELTA_SE, DELTA_ZERO},
-  {DELTA_SSW, DELTA_SSE, DELTA_SWW, DELTA_SEE,
-   DELTA_NWW, DELTA_NEE, DELTA_NNW, DELTA_NNE, DELTA_ZERO},
-  {DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-};   
-
-const SquareDelta PawnPush[2] = {
-  DELTA_N, DELTA_S
-};
-
 
 ////
 //// Functions
 ////
 
-/// Translating piece types to/from English piece letters:
+/// Translating piece types to/from English piece letters
 
-static const char PieceChars[] = " pnbrqk";
+static const string PieceChars(" pnbrqk PNBRQK");
 
-char piece_type_to_char(PieceType pt, bool upcase = false) {
+char piece_type_to_char(PieceType pt, bool upcase) {
-  return upcase? toupper(PieceChars[pt]) : PieceChars[pt];
+
+  return PieceChars[pt + upcase * 7];
 }
 
 PieceType piece_type_from_char(char c) {
-  const char *ch = strchr(PieceChars, tolower(c));
+
-  return ch? PieceType(ch - PieceChars) : NO_PIECE_TYPE;
+  size_t idx = PieceChars.find(c);
-}
+
-
+  return idx != string::npos ? PieceType(idx % 7) : NO_PIECE_TYPE;
-
-/// piece_is_ok() and piece_type_is_ok(), for debugging:
-
-bool piece_is_ok(Piece pc) {
-  return
-    piece_type_is_ok(type_of_piece(pc)) &&
-    color_is_ok(color_of_piece(pc));
-}
-
-bool piece_type_is_ok(PieceType pc) {
-  return pc >= PAWN && pc <= KING;
 }

src/piece.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -21,16 +21,15 @@
 #if !defined(PIECE_H_INCLUDED)
 #define PIECE_H_INCLUDED
 
-//// 
+////
 //// Includes
 ////
 
 #include "color.h"
-#include "misc.h"
 #include "square.h"
 
 
-//// 
+////
 //// Types
 ////
 
@@ -47,18 +46,15 @@ enum Piece {
 
 
 ////
-//// Constants and variables
+//// Constants
 ////
 
-const PieceType PieceTypeMin = PAWN;
+const int SlidingArray[18] = {
-const PieceType PieceTypeMax = KING;
+  0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0
-
+};
-extern const int SlidingArray[18];
-extern const SquareDelta Directions[16][16];   
-extern const SquareDelta PawnPush[2];
 
 
-//// 
+////
 //// Inline functions
 ////
 
@@ -83,51 +79,33 @@ inline Piece piece_of_color_and_type(Color c, PieceType pt) {
   return Piece((int(c) << 3) | int(pt));
 }
 
-inline Piece pawn_of_color(Color c) {
-  return piece_of_color_and_type(c, PAWN);
-}
-
-inline Piece knight_of_color(Color c) {
-  return piece_of_color_and_type(c, KNIGHT);
-}
-
-inline Piece bishop_of_color(Color c) {
-  return piece_of_color_and_type(c, BISHOP);
-}
-
-inline Piece rook_of_color(Color c) {
-  return piece_of_color_and_type(c, ROOK);
-}
-
-inline Piece queen_of_color(Color c) {
-  return piece_of_color_and_type(c, QUEEN);
-}
-
-inline Piece king_of_color(Color c) {
-  return piece_of_color_and_type(c, KING);
-}
-
 inline int piece_is_slider(Piece p) {
   return SlidingArray[int(p)];
 }
 
-inline int piece_type_is_slider(PieceType pt) {
+inline int piece_is_slider(PieceType pt) {
   return SlidingArray[int(pt)];
 }
 
 inline SquareDelta pawn_push(Color c) {
-  return PawnPush[c];
+    return (c == WHITE ? DELTA_N : DELTA_S);
 }
-  
+
+inline bool piece_type_is_ok(PieceType pc) {
+  return pc >= PAWN && pc <= KING;
+}
+
+inline bool piece_is_ok(Piece pc) {
+  return piece_type_is_ok(type_of_piece(pc)) && color_is_ok(color_of_piece(pc));
+}
+
 
 ////
 //// Prototypes
 ////
 
-extern char piece_type_to_char(PieceType pt, bool upcase);
+extern char piece_type_to_char(PieceType pt, bool upcase = false);
 extern PieceType piece_type_from_char(char c);
-extern bool piece_is_ok(Piece pc);
-extern bool piece_type_is_ok(PieceType pt);
 
 
 #endif // !defined(PIECE_H_INCLUDED)

src/position.h

@@ -27,6 +27,10 @@
 // Forcing value to bool 'true' or 'false' (performance warning)
 #pragma warning(disable: 4800)
 
+// Conditional expression is constant
+#pragma warning(disable: 4127)
+
+
 #endif
 
 ////
@@ -38,7 +42,6 @@
 #include "direction.h"
 #include "move.h"
 #include "piece.h"
-#include "phase.h"
 #include "square.h"
 #include "value.h"
 
@@ -61,7 +64,7 @@ const int MaxGameLength = 220;
 //// Types
 ////
 
-/// Castle rights, encoded as bit fields:
+/// Castle rights, encoded as bit fields
 
 enum CastleRights {
   NO_CASTLES = 0,
@@ -72,22 +75,28 @@ enum CastleRights {
   ALL_CASTLES = 15
 };
 
+/// Game phase
+enum Phase {
+  PHASE_ENDGAME = 0,
+  PHASE_MIDGAME = 128
+};
 
-/// The UndoInfo struct stores information we need to restore a Position
-/// object to its previous state when we retract a move.  Whenever a move
-/// is made on the board (by calling Position::do_move), an UndoInfo object
-/// must be passed as a parameter.  When the move is unmade (by calling
-/// Position::undo_move), the same UndoInfo object must be passed again.
 
-struct UndoInfo {
+/// The StateInfo struct stores information we need to restore a Position
-  int castleRights;
+/// object to its previous state when we retract a move. Whenever a move
-  Square epSquare;
+/// is made on the board (by calling Position::do_move), an StateInfo object
-  Bitboard checkersBB;
+/// must be passed as a parameter.
+
+struct StateInfo {
   Key key, pawnKey, materialKey;
-  int rule50;
+  int castleRights, rule50;
-  Move lastMove;
+  Square epSquare;
-  PieceType capture;
   Value mgValue, egValue;
+
+  PieceType capture;
+  Bitboard checkersBB;
+  Move lastMove;
+  StateInfo* previous;
 };
 
 
@@ -122,13 +131,13 @@ class Position {
 public:
   // Constructors
   Position() {};
-  Position(const Position &pos);
+  Position(const Position& pos);
-  Position(const std::string &fen);
+  Position(const std::string& fen);
 
   // Text input/output
-  void from_fen(const std::string &fen);
+  void from_fen(const std::string& fen);
   const std::string to_fen() const;
-  void print() const;
+  void print(Move m = MOVE_NONE) const;
 
   // Copying
   void copy(const Position &pos);
@@ -174,13 +183,13 @@ public:
   // Number of pieces of each color and type
   int piece_count(Color c, PieceType pt) const;
 
-  // The en passant square:
+  // The en passant square
   Square ep_square() const;
 
   // Current king position for each color
   Square king_square(Color c) const;
 
-  // Castling rights.
+  // Castling rights
   bool can_castle_kingside(Color c) const;
   bool can_castle_queenside(Color c) const;
   bool can_castle(Color c) const;
@@ -197,6 +206,7 @@ public:
 
   // Bitboards for pinned pieces and discovered check candidates
   Bitboard discovered_check_candidates(Color c) const;
+  Bitboard pinned_pieces(Color c, Bitboard& p) const;
   Bitboard pinned_pieces(Color c) const;
 
   // Checking pieces
@@ -215,7 +225,7 @@ public:
   template<PieceType>
   Bitboard piece_attacks_square(Square f, Square t) const; // Dispatch at compile-time
 
-  bool piece_attacks_square(Square f, Square t) const; // Dispatch at run-time
+  bool piece_attacks_square(Piece p, Square f, Square t) const; // Dispatch at run-time
 
   // Properties of moves
   bool pl_move_is_legal(Move m) const;
@@ -242,17 +252,17 @@ public:
   bool square_is_weak(Square s, Color c) const;
 
   // Doing and undoing moves
-  void backup(UndoInfo &u) const;
+  void setStartState(const StateInfo& st);
-  void restore(const UndoInfo &u);
+  void do_move(Move m, StateInfo& st);
-  void do_move(Move m, UndoInfo &u);
+  void do_move(Move m, StateInfo& st, Bitboard dcCandidates);
-  void do_move(Move m, UndoInfo &u, Bitboard dcCandidates);
+  void undo_move(Move m);
-  void undo_move(Move m, const UndoInfo &u);
+  void do_null_move(StateInfo& st);
-  void do_null_move(UndoInfo &u);
+  void undo_null_move();
-  void undo_null_move(const UndoInfo &u);
 
   // Static exchange evaluation
   int see(Square from, Square to) const;
   int see(Move m) const;
+  int see(Square to) const;
 
   // Accessing hash keys
   Key get_key() const;
@@ -267,7 +277,7 @@ public:
   Value mg_pst_delta(Move m) const;
 
   // Game termination checks
-  bool is_mate();
+  bool is_mate() const;
   bool is_draw() const;
 
   // Check if one side threatens a mate in one
@@ -291,6 +301,7 @@ public:
   static void init_piece_square_tables();
 
 private:
+
   // Initialization helper functions (used while setting up a position)
   void clear();
   void put_piece(Piece p, Square s);
@@ -298,17 +309,20 @@ private:
   void allow_ooo(Color c);
 
   // Helper functions for doing and undoing moves
-  void do_capture_move(Move m, PieceType capture, Color them, Square to);
+  void do_capture_move(PieceType capture, Color them, Square to);
   void do_castle_move(Move m);
-  void do_promotion_move(Move m, UndoInfo &u);
+  void do_promotion_move(Move m);
   void do_ep_move(Move m);
   void undo_castle_move(Move m);
-  void undo_promotion_move(Move m, const UndoInfo &u);
+  void undo_promotion_move(Move m);
   void undo_ep_move(Move m);
   void find_checkers();
 
-  template<PieceType Piece, bool FindPinned>
+  template<PieceType Piece>
-  Bitboard hidden_checks(Color c, Square ksq) const;
+  void update_checkers(Bitboard* pCheckersBB, Square ksq, Square from, Square to, Bitboard dcCandidates);
+
+  template<bool FindPinned>
+  Bitboard hidden_checkers(Color c) const;
 
   // Computing hash keys from scratch (for initialization and debugging)
   Key compute_key() const;
@@ -316,15 +330,16 @@ private:
   Key compute_material_key() const;
 
   // Computing incremental evaluation scores and material counts
-  Value mg_pst(Color c, PieceType pt, Square s) const;
+  enum GamePhase {
-  Value eg_pst(Color c, PieceType pt, Square s) const;
+      MidGame,
-  Value compute_mg_value() const;
+      EndGame
-  Value compute_eg_value() const;
+  };
+  template<GamePhase> Value pst(Color c, PieceType pt, Square s) const;
+  template<GamePhase> Value compute_value() const;
   Value compute_non_pawn_material(Color c) const;
 
   // Bitboards
   Bitboard byColorBB[2], byTypeBB[8];
-  Bitboard checkersBB;
 
   // Board
   Piece board[64];
@@ -337,16 +352,14 @@ private:
   int index[64];
 
   // Other info
-  Color sideToMove;
-  int castleRights;
-  File initialKFile, initialKRFile, initialQRFile;
-  Square epSquare;
   Square kingSquare[2];
-  Move lastMove;
+  Color sideToMove;
-  Key key, pawnKey, materialKey, history[MaxGameLength];
+  int gamePly;
-  int rule50, gamePly;
+  Key history[MaxGameLength];
-  Value mgValue, egValue;
   Value npMaterial[2];
+  File initialKFile, initialKRFile, initialQRFile;
+  StateInfo startState;
+  StateInfo* st;
 
   // Static variables
   static int castleRightsMask[64];
@@ -497,7 +510,7 @@ inline Square Position::piece_list(Color c, PieceType pt, int index) const {
 }
 
 inline Square Position::ep_square() const {
-  return epSquare;
+  return st->epSquare;
 }
 
 inline Square Position::king_square(Color c) const {
@@ -505,11 +518,11 @@ inline Square Position::king_square(Color c) const {
 }
 
 inline bool Position::can_castle_kingside(Color side) const {
-  return castleRights & (1+int(side));
+  return st->castleRights & (1+int(side));
 }
 
 inline bool Position::can_castle_queenside(Color side) const {
-  return castleRights & (4+4*int(side));
+  return st->castleRights & (4+4*int(side));
 }
 
 inline bool Position::can_castle(Color side) const {
@@ -525,7 +538,12 @@ inline Square Position::initial_qr_square(Color c) const {
 }
 
 inline Bitboard Position::pawn_attacks(Color c, Square s) const {
-  return StepAttackBB[pawn_of_color(c)][s];
+  return StepAttackBB[piece_of_color_and_type(c, PAWN)][s];
+}
+
+template<>
+inline Bitboard Position::piece_attacks<PAWN>(Square s) const {
+  return StepAttackBB[piece_of_color_and_type(opposite_color(sideToMove), PAWN)][s];
 }
 
 template<>
@@ -554,11 +572,11 @@ inline Bitboard Position::piece_attacks<KING>(Square s) const {
 }
 
 inline Bitboard Position::checkers() const {
-  return checkersBB;
+  return st->checkersBB;
 }
 
 inline bool Position::is_check() const {
-  return checkersBB != EmptyBoardBB;
+  return st->checkersBB != EmptyBoardBB;
 }
 
 inline bool Position::pawn_attacks_square(Color c, Square f, Square t) const {
@@ -570,6 +588,16 @@ Bitboard Position::piece_attacks_square(Square f, Square t) const {
   return bit_is_set(piece_attacks<Piece>(f), t);
 }
 
+inline Bitboard Position::attacks_to(Square s, Color c) const {
+
+  return attacks_to(s) & pieces_of_color(c);
+}
+
+inline bool Position::square_is_attacked(Square s, Color c) const {
+
+  return attacks_to(s, c) != EmptyBoardBB;
+}
+
 inline bool Position::pawn_is_passed(Color c, Square s) const {
   return !(pawns(opposite_color(c)) & passed_pawn_mask(c, s));
 }
@@ -595,19 +623,21 @@ inline bool Position::square_is_weak(Square s, Color c) const {
 }
 
 inline Key Position::get_key() const {
-  return key;
+  return st->key;
 }
 
 inline Key Position::get_pawn_key() const {
-  return pawnKey;
+  return st->pawnKey;
 }
 
 inline Key Position::get_material_key() const {
-  return materialKey;
+  return st->materialKey;
 }
 
-inline Value Position::mg_pst(Color c, PieceType pt, Square s) const {
+template<Position::GamePhase Phase>
-  return MgPieceSquareTable[piece_of_color_and_type(c, pt)][s];
+inline Value Position::pst(Color c, PieceType pt, Square s) const {
+  return (Phase == MidGame ? MgPieceSquareTable[piece_of_color_and_type(c, pt)][s]
+                           : EgPieceSquareTable[piece_of_color_and_type(c, pt)][s]);
 }
 
 inline Value Position::mg_pst_delta(Move m) const {
@@ -615,16 +645,12 @@ inline Value Position::mg_pst_delta(Move m) const {
         -MgPieceSquareTable[piece_on(move_from(m))][move_from(m)];
 }
 
-inline Value Position::eg_pst(Color c, PieceType pt, Square s) const {
-  return EgPieceSquareTable[piece_of_color_and_type(c, pt)][s];
-}
-
 inline Value Position::mg_value() const {
-  return mgValue;
+  return st->mgValue;
 }
 
 inline Value Position::eg_value() const {
-  return egValue;
+  return st->egValue;
 }
 
 inline Value Position::non_pawn_material(Color c) const {
@@ -633,15 +659,9 @@ inline Value Position::non_pawn_material(Color c) const {
 
 inline Phase Position::game_phase() const {
 
-  // The purpose of the Value(325) terms below is to make sure the difference
+  // Values modified by Joona Kiiski
-  // between MidgameLimit and EndgameLimit is a power of 2, which should make
+  static const Value MidgameLimit = Value(15713);
-  // the division at the end of the function a bit faster.
+  static const Value EndgameLimit = Value(4428);
-  static const Value MidgameLimit =  2 * QueenValueMidgame
-                                   + 2 * RookValueMidgame
-                                   + 6 * BishopValueMidgame
-                                   + Value(325);
-
-  static const Value EndgameLimit = 4 * RookValueMidgame - Value(325);
 
   Value npm = non_pawn_material(WHITE) + non_pawn_material(BLACK);
 
@@ -656,34 +676,34 @@ inline Phase Position::game_phase() const {
 inline bool Position::move_is_deep_pawn_push(Move m) const {
 
   Color c = side_to_move();
-  return   piece_on(move_from(m)) == pawn_of_color(c)
+  return   piece_on(move_from(m)) == piece_of_color_and_type(c, PAWN)
         && relative_rank(c, move_to(m)) > RANK_4;
 }
 
 inline bool Position::move_is_pawn_push_to_7th(Move m) const {
 
   Color c = side_to_move();
-  return   piece_on(move_from(m)) == pawn_of_color(c)
+  return   piece_on(move_from(m)) == piece_of_color_and_type(c, PAWN)
         && relative_rank(c, move_to(m)) == RANK_7;
 }
 
 inline bool Position::move_is_passed_pawn_push(Move m) const {
 
   Color c = side_to_move();
-  return   piece_on(move_from(m)) == pawn_of_color(c)
+  return   piece_on(move_from(m)) == piece_of_color_and_type(c, PAWN)
         && pawn_is_passed(c, move_to(m));
 }
 
 inline bool Position::move_was_passed_pawn_push(Move m) const {
 
   Color c = opposite_color(side_to_move());
-  return   piece_on(move_to(m)) == pawn_of_color(c)
+  return   piece_on(move_to(m)) == piece_of_color_and_type(c, PAWN)
         && pawn_is_passed(c, move_to(m));
 }
 
 inline int Position::rule_50_counter() const {
 
-  return rule50;
+  return st->rule50;
 }
 
 inline bool Position::opposite_colored_bishops() const {
@@ -698,5 +718,14 @@ inline bool Position::has_pawn_on_7th(Color c) const {
   return pawns(c) & relative_rank_bb(c, RANK_7);
 }
 
+inline bool Position::move_is_capture(Move m) const {
+
+  // Move must not be MOVE_NONE !
+
+  return (   !square_is_empty(move_to(m))
+          && (color_of_piece_on(move_to(m)) != color_of_piece_on(move_from(m)))
+         )
+         || move_is_ep(m);
+}
 
 #endif // !defined(POSITION_H_INCLUDED)

src/psqtab.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -25,7 +25,6 @@
 //// Includes
 ////
 
-#include "position.h"
 #include "value.h"
 
 

src/san.cpp

@@ -31,6 +31,7 @@
 #include "movepick.h"
 #include "san.h"
 
+extern SearchStack EmptySearchStack;
 
 ////
 //// Local definitions
@@ -50,7 +51,7 @@ namespace {
 
   /// Functions
 
-  Ambiguity move_ambiguity(Position &pos, Move m);
+  Ambiguity move_ambiguity(const Position& pos, Move m);
   const std::string time_string(int milliseconds);
   const std::string score_string(Value v);
 }
@@ -61,206 +62,227 @@ namespace {
 ////
 
 /// move_to_san() takes a position and a move as input, where it is assumed
-/// that the move is a legal move from the position.  The return value is
+/// that the move is a legal move from the position. The return value is
 /// a string containing the move in short algebraic notation.
 
-const std::string move_to_san(Position &pos, Move m) {
+const std::string move_to_san(const Position& pos, Move m) {
-  std::string str;
 
   assert(pos.is_ok());
   assert(move_is_ok(m));
 
-  if(m == MOVE_NONE) {
+  Square from, to;
-    str = "(none)";
+  PieceType pt;
-    return str;
-  }
-  else if(m == MOVE_NULL) {
-    str = "(null)";
-    return str;
-  }
-  else if(move_is_long_castle(m))
-    str = "O-O-O";
-  else if(move_is_short_castle(m))
-    str = "O-O";
-  else {
-    Square from, to;
-    Piece pc;
 
-    from = move_from(m);
+  from = move_from(m);
-    to = move_to(m);
+  to = move_to(m);
-    pc = pos.piece_on(move_from(m));
+  pt = type_of_piece(pos.piece_on(move_from(m)));
 
-    str = "";
+  std::string san = "";
 
-    if(type_of_piece(pc) == PAWN) {
+  if (m == MOVE_NONE)
-      if(pos.move_is_capture(m))
+      return "(none)";
-        str += file_to_char(square_file(move_from(m)));
+  else if (m == MOVE_NULL)
-    }
+      return "(null)";
-    else {
+  else if (move_is_long_castle(m) || (int(to - from) == -2 && pt == KING))
-      str += piece_type_to_char(type_of_piece(pc), true);
+      san = "O-O-O";
-
+  else if (move_is_short_castle(m) || (int(to - from) == 2 && pt == KING))
-      Ambiguity amb = move_ambiguity(pos, m);
+      san = "O-O";
-      switch(amb) {
+  else
-
+  {
-      case AMBIGUITY_NONE:
+      if (pt != PAWN)
-        break;
+      {
-
+          san += piece_type_to_char(pt, true);
-      case AMBIGUITY_FILE:
+          switch (move_ambiguity(pos, m)) {
-        str += file_to_char(square_file(from));
+          case AMBIGUITY_NONE:
-        break;
+            break;
-
+          case AMBIGUITY_FILE:
-      case AMBIGUITY_RANK:
+            san += file_to_char(square_file(from));
-        str += rank_to_char(square_rank(from));
+            break;
-        break;
+          case AMBIGUITY_RANK:
-
+            san += rank_to_char(square_rank(from));
-      case AMBIGUITY_BOTH:
+            break;
-        str += square_to_string(from);
+          case AMBIGUITY_BOTH:
-        break;
+            san += square_to_string(from);
-
+            break;
-      default:
+          default:
-        assert(false);
+            assert(false);
+          }
+      }
+      if (pos.move_is_capture(m))
+      {
+          if (pt == PAWN)
+              san += file_to_char(square_file(move_from(m)));
+          san += "x";
+      }
+      san += square_to_string(move_to(m));
+      if (move_promotion(m))
+      {
+          san += '=';
+          san += piece_type_to_char(move_promotion(m), true);
       }
-    }
-
-    if(pos.move_is_capture(m))
-      str += "x";
-
-    str += square_to_string(move_to(m));
-
-    if(move_promotion(m)) {
-      str += "=";
-      str += piece_type_to_char(move_promotion(m), true);
-    }
   }
-
   // Is the move check?  We don't use pos.move_is_check(m) here, because
   // Position::move_is_check doesn't detect all checks (not castling moves,
   // promotions and en passant captures).
-  UndoInfo u;
+  StateInfo st;
-  pos.do_move(m, u);
+  Position p(pos);
-  if(pos.is_check())
+  p.do_move(m, st);
-    str += pos.is_mate()? "#" : "+";
+  if (p.is_check())
-  pos.undo_move(m, u);
+      san += p.is_mate()? "#" : "+";
 
-  return str;
+  return san;
 }
 
 
 /// move_from_san() takes a position and a string as input, and tries to
-/// interpret the string as a move in short algebraic notation.  On success,
+/// interpret the string as a move in short algebraic notation. On success,
 /// the move is returned.  On failure (i.e. if the string is unparsable, or
 /// if the move is illegal or ambiguous), MOVE_NONE is returned.
 
-Move move_from_san(Position &pos, const std::string &movestr) {
+Move move_from_san(const Position& pos, const std::string& movestr) {
+
   assert(pos.is_ok());
 
-  MovePicker mp = MovePicker(pos, false, MOVE_NONE, MOVE_NONE, MOVE_NONE,
+  MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);
-                             MOVE_NONE, OnePly);
 
   // Castling moves
-  if(movestr == "O-O-O") {
+  if (movestr == "O-O-O" || movestr == "O-O-O+")
-    Move m;
+  {
-    while((m = mp.get_next_move()) != MOVE_NONE)
+      Move m;
-      if(move_is_long_castle(m) && pos.pl_move_is_legal(m))
+      while ((m = mp.get_next_move()) != MOVE_NONE)
-        return m;
+          if (move_is_long_castle(m) && pos.pl_move_is_legal(m))
-    return MOVE_NONE;
+              return m;
-  }
-  else if(movestr == "O-O") {
-    Move m;
-    while((m = mp.get_next_move()) != MOVE_NONE)
-      if(move_is_short_castle(m) && pos.pl_move_is_legal(m))
-        return m;
-    return MOVE_NONE;
-  }
 
-  // Normal moves
-  const char *cstr = movestr.c_str();
-  const char *c;
-  char *cc;
-  char str[10];
-  int i;
-
-  // Initialize str[] by making a copy of movestr with the characters
-  // 'x', '=', '+' and '#' removed.
-  cc = str;
-  for(i=0, c=cstr; i<10 && *c!='\0' && *c!='\n' && *c!=' '; i++, c++)
-    if(!strchr("x=+#", *c)) {
-      *cc = strchr("nrq", *c)? toupper(*c) : *c;
-      cc++;
-    }
-  *cc = '\0';
-
-  size_t left = 0, right = strlen(str) - 1;
-  PieceType pt = NO_PIECE_TYPE, promotion;
-  Square to;
-  File fromFile = FILE_NONE;
-  Rank fromRank = RANK_NONE;
-
-  // Promotion?
-  if(strchr("BNRQ", str[right])) {
-    promotion = piece_type_from_char(str[right]);
-    right--;
-  }
-  else
-    promotion = NO_PIECE_TYPE;
-
-  // Find the moving piece:
-  if(left < right) {
-    if(strchr("BNRQK", str[left])) {
-      pt = piece_type_from_char(str[left]);
-      left++;
-    }
-    else
-      pt = PAWN;
-  }
-
-  // Find the to square:
-  if(left < right) {
-    if(str[right] < '1' || str[right] > '8' ||
-       str[right-1] < 'a' || str[right-1] > 'h')
       return MOVE_NONE;
-    to = make_square(file_from_char(str[right-1]), rank_from_char(str[right]));
-    right -= 2;
   }
-  else
+  else if (movestr == "O-O" || movestr == "O-O+")
+  {
+      Move m;
+      while ((m = mp.get_next_move()) != MOVE_NONE)
+          if (move_is_short_castle(m) && pos.pl_move_is_legal(m))
+              return m;
+
     return MOVE_NONE;
-
-  // Find the file and/or rank of the from square:
-  if(left <= right) {
-    if(strchr("abcdefgh", str[left])) {
-      fromFile = file_from_char(str[left]);
-      left++;
-    }
-    if(strchr("12345678", str[left]))
-      fromRank = rank_from_char(str[left]);
   }
 
-  // Look for a matching move:
+  // Normal moves. We use a simple FSM to parse the san string.
+  enum { START, TO_FILE, TO_RANK, PROMOTION_OR_CHECK, PROMOTION, CHECK, END };
+  static const std::string pieceLetters = "KQRBN";
+  PieceType pt = NO_PIECE_TYPE, promotion = NO_PIECE_TYPE;
+  File fromFile = FILE_NONE, toFile = FILE_NONE;
+  Rank fromRank = RANK_NONE, toRank = RANK_NONE;
+  Square to;
+  int state = START;
+
+  for (size_t i = 0; i < movestr.length(); i++)
+  {
+      char type, c = movestr[i];
+      if (pieceLetters.find(c) != std::string::npos)
+          type = 'P';
+      else if (c >= 'a' && c <= 'h')
+          type = 'F';
+      else if (c >= '1' && c <= '8')
+          type = 'R';
+      else
+          type = c;
+
+      switch (type) {
+      case 'P':
+          if (state == START)
+          {
+              pt = piece_type_from_char(c);
+              state = TO_FILE;
+          }
+          else if (state == PROMOTION)
+          {
+              promotion = piece_type_from_char(c);
+              state = (i < movestr.length() - 1) ? CHECK : END;
+          }
+          else
+              return MOVE_NONE;
+          break;
+      case 'F':
+          if (state == START)
+          {
+              pt = PAWN;
+              fromFile = toFile = file_from_char(c);
+              state = TO_RANK;
+          }
+          else if (state == TO_FILE)
+          {
+              toFile = file_from_char(c);
+              state = TO_RANK;
+          }
+          else if (state == TO_RANK && toFile != FILE_NONE)
+          {
+              // Previous file was for disambiguation
+              fromFile = toFile;
+              toFile = file_from_char(c);
+          }
+          else
+              return MOVE_NONE;
+          break;
+      case 'R':
+          if (state == TO_RANK)
+          {
+              toRank = rank_from_char(c);
+              state = (i < movestr.length() - 1) ? PROMOTION_OR_CHECK : END;
+          }
+          else if (state == TO_FILE && fromRank == RANK_NONE)
+          {
+              // It's a disambiguation rank instead of a file
+              fromRank = rank_from_char(c);
+          }
+          else
+              return MOVE_NONE;
+          break;
+      case 'x': case 'X':
+          if (state == TO_RANK)
+          {
+              // Previous file was for disambiguation, or it's a pawn capture
+              fromFile = toFile;
+              state = TO_FILE;
+          }
+          else if (state != TO_FILE)
+              return MOVE_NONE;
+          break;
+      case '=':
+          if (state == PROMOTION_OR_CHECK)
+              state = PROMOTION;
+          else
+              return MOVE_NONE;
+          break;
+      case '+': case '#':
+          if (state == PROMOTION_OR_CHECK || state == CHECK)
+              state = END;
+          else
+              return MOVE_NONE;
+          break;
+      default:
+          return MOVE_NONE;
+          break;
+      }
+  }
+
+  if (state != END)
+      return MOVE_NONE;
+
+  // Look for a matching move
   Move m, move = MOVE_NONE;
+  to = make_square(toFile, toRank);
   int matches = 0;
 
-  while((m = mp.get_next_move()) != MOVE_NONE) {
+  while ((m = mp.get_next_move()) != MOVE_NONE)
-    bool match = true;
+      if (   pos.type_of_piece_on(move_from(m)) == pt
-    if(pos.type_of_piece_on(move_from(m)) != pt)
+          && move_to(m) == to
-      match = false;
+          && move_promotion(m) == promotion
-    else if(move_to(m) != to)
+          && (fromFile == FILE_NONE || fromFile == square_file(move_from(m)))
-      match = false;
+          && (fromRank == RANK_NONE || fromRank == square_rank(move_from(m))))
-    else if(move_promotion(m) != promotion)
+      {
-      match = false;
+          move = m;
-    else if(fromFile != FILE_NONE && fromFile != square_file(move_from(m)))
+          matches++;
-      match = false;
+      }
-    else if(fromRank != RANK_NONE && fromRank != square_rank(move_from(m)))
+  return (matches == 1 ? move : MOVE_NONE);
-      match = false;
-    if(match) {
-      move = m;
-      matches++;
-    }
-  }
-
-  if(matches == 1)
-    return move;
-  else
-    return MOVE_NONE;
 }
 
 
@@ -271,34 +293,31 @@ Move move_from_san(Position &pos, const std::string &movestr) {
 /// length of 80 characters.  After a line break, 'startColumn' spaces are
 /// inserted at the beginning of the new line.
 
-const std::string line_to_san(const Position &pos, Move line[], int startColumn,
+const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines) {
-                              bool breakLines) {
+
-  Position p = Position(pos);
+  StateInfo st;
-  UndoInfo u;
   std::stringstream s;
   std::string moveStr;
-  size_t length, maxLength;
+  size_t length = 0;
+  size_t maxLength = 80 - startColumn;
+  Position p(pos);
 
-  length = 0;
+  for (int i = 0; line[i] != MOVE_NONE; i++)
-  maxLength = 80 - startColumn;
+  {
+      moveStr = move_to_san(p, line[i]);
+      length += moveStr.length() + 1;
+      if (breakLines && length > maxLength)
+      {
+          s << '\n' << std::setw(startColumn) << ' ';
+          length = moveStr.length() + 1;
+      }
+      s << moveStr << ' ';
 
-  for(int i = 0; line[i] != MOVE_NONE; i++) {
+      if (line[i] == MOVE_NULL)
-    moveStr = move_to_san(p, line[i]);
+          p.do_null_move(st);
-    length += moveStr.length() + 1;
+      else
-    if(breakLines && length > maxLength) {
+          p.do_move(line[i], st);
-      s << "\n";
-      for(int j = 0; j < startColumn; j++)
-        s << " ";
-      length = moveStr.length() + 1;
-    }
-    s << moveStr << " ";
-
-    if(line[i] == MOVE_NULL)
-      p.do_null_move(u);
-    else
-      p.do_move(line[i], u);
   }
-
   return s.str();
 }
 
@@ -307,26 +326,26 @@ const std::string line_to_san(const Position &pos, Move line[], int startColumn,
 /// It is used to write search information to the log file (which is created
 /// when the UCI parameter "Use Search Log" is "true").
 
-const std::string pretty_pv(const Position &pos, int time, int depth,
+const std::string pretty_pv(const Position& pos, int time, int depth,
                             uint64_t nodes, Value score, Move pv[]) {
   std::stringstream s;
 
   // Depth
-  s << std::setw(2) << std::setfill(' ') << depth << "  ";
+  s << std::setw(2) << depth << "  ";
 
   // Score
   s << std::setw(8) << score_string(score);
 
   // Time
-  s << std::setw(8) << std::setfill(' ') << time_string(time) << " ";
+  s << std::setw(8) << time_string(time) << " ";
 
   // Nodes
-  if(nodes < 1000000ULL)
+  if (nodes < 1000000ULL)
-    s << std::setw(8) << std::setfill(' ') << nodes << " ";
+    s << std::setw(8) << nodes << " ";
-  else if(nodes < 1000000000ULL)
+  else if (nodes < 1000000000ULL)
-    s << std::setw(7) << std::setfill(' ') << nodes/1000ULL << 'k' << " ";
+    s << std::setw(7) << nodes/1000ULL << 'k' << " ";
   else
-    s << std::setw(7) << std::setfill(' ') << nodes/1000000ULL << 'M' << " ";
+    s << std::setw(7) << nodes/1000000ULL << 'M' << " ";
 
   // PV
   s << line_to_san(pos, pv, 30, true);
@@ -337,82 +356,80 @@ const std::string pretty_pv(const Position &pos, int time, int depth,
 
 namespace {
 
-  Ambiguity move_ambiguity(Position &pos, Move m) {
+  Ambiguity move_ambiguity(const Position& pos, Move m) {
-    Square from, to;
-    Piece pc;
 
-    from = move_from(m);
+    Square from = move_from(m);
-    to = move_to(m);
+    Square to = move_to(m);
-    pc = pos.piece_on(from);
+    Piece pc = pos.piece_on(from);
 
     // King moves are never ambiguous, because there is never two kings of
     // the same color.
-    if(type_of_piece(pc) == KING)
+    if (type_of_piece(pc) == KING)
-      return AMBIGUITY_NONE;
+        return AMBIGUITY_NONE;
 
-    MovePicker mp = MovePicker(pos, false, MOVE_NONE, MOVE_NONE, MOVE_NONE,
+    MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);
-                               MOVE_NONE, OnePly);
     Move mv, moveList[8];
-    int i, j, n;
 
-    n = 0;
+    int n = 0;
-    while((mv = mp.get_next_move()) != MOVE_NONE)
+    while ((mv = mp.get_next_move()) != MOVE_NONE)
-      if(move_to(mv) == to && pos.piece_on(move_from(mv)) == pc
+        if (move_to(mv) == to && pos.piece_on(move_from(mv)) == pc && pos.pl_move_is_legal(mv))
-         && pos.pl_move_is_legal(mv))
+            moveList[n++] = mv;
-        moveList[n++] = mv;
-    if(n == 1)
-      return AMBIGUITY_NONE;
 
-    j = 0;
+    if (n == 1)
-    for(i = 0; i < n; i++)
+        return AMBIGUITY_NONE;
-      if(square_file(move_from(moveList[i])) == square_file(from))
-        j++;
-    if(j == 1)
-      return AMBIGUITY_FILE;
 
-    j = 0;
+    int f = 0, r = 0;
-    for(i = 0; i < n; i++)
+    for (int i = 0; i < n; i++)
-      if(square_rank(move_from(moveList[i])) == square_rank(from))
+    {
-        j++;
+        if (square_file(move_from(moveList[i])) == square_file(from))
-    if(j == 1)
+            f++;
-      return AMBIGUITY_RANK;
+
+        if (square_rank(move_from(moveList[i])) == square_rank(from))
+            r++;
+    }
+    if (f == 1)
+        return AMBIGUITY_FILE;
+
+    if (r == 1)
+        return AMBIGUITY_RANK;
 
     return AMBIGUITY_BOTH;
   }
 
 
   const std::string time_string(int milliseconds) {
+
     std::stringstream s;
+    s << std::setfill('0');
 
-    int hours = milliseconds / (1000 * 60 * 60);
+    int hours = milliseconds / (1000*60*60);
-    int minutes = (milliseconds - hours*1000*60*60) / (60*1000);
+    int minutes = (milliseconds - hours*1000*60*60) / (1000*60);
-    int seconds = (milliseconds - hours*1000*60*60 - minutes*60*1000) / 1000;
+    int seconds = (milliseconds - hours*1000*60*60 - minutes*1000*60) / 1000;
 
-    if(hours)
+    if (hours)
-      s << hours << ':';
+        s << hours << ':';
-    s << std::setw(2) << std::setfill('0') << minutes << ':';
-    s << std::setw(2) << std::setfill('0') << seconds;
 
+    s << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
     return s.str();
   }
 
 
   const std::string score_string(Value v) {
+
     std::stringstream s;
 
-    if(abs(v) >= VALUE_MATE - 200) {
+    if (v >= VALUE_MATE - 200)
-      if(v < 0)
-        s << "-#" << (VALUE_MATE + v) / 2;
-      else
         s << "#" << (VALUE_MATE - v + 1) / 2;
-    }
+    else if(v <= -VALUE_MATE + 200)
-    else {
+        s << "-#" << (VALUE_MATE + v) / 2;
-      float floatScore = float(v) / float(PawnValueMidgame);
+    else
-      if(v >= 0)
+    {
-        s << '+';
+        float floatScore = float(v) / float(PawnValueMidgame);
-      s << std::setprecision(2) << std::fixed << floatScore;
+        if (v >= 0)
+            s << '+';
+
+        s << std::setprecision(2) << std::fixed << floatScore;
     }
     return s.str();
   }
-
 }

src/san.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -36,12 +36,9 @@
 //// Prototypes
 ////
 
-extern const std::string move_to_san(Position &pos, Move m);
+extern const std::string move_to_san(const Position& pos, Move m);
-extern Move move_from_san(Position &pos, const std::string &str);
+extern Move move_from_san(const Position& pos, const std::string& str);
-extern const std::string line_to_san(const Position &pos, Move line[],
+extern const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines);
-                                     int startColumn, bool breakLines);
+extern const std::string pretty_pv(const Position& pos, int time, int depth, uint64_t nodes, Value score, Move pv[]);
-extern const std::string pretty_pv(const Position &pos, int time, int depth,
-                                   uint64_t nodes, Value score, Move pv[]);
-
 
 #endif // !defined(SAN_H_INCLUDED)

src/scale.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

src/search.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -25,7 +25,6 @@
 //// Includes
 ////
 
-#include "types.h"
 #include "depth.h"
 #include "history.h"
 #include "lock.h"
@@ -41,6 +40,7 @@
 
 const int PLY_MAX = 100;
 const int PLY_MAX_PLUS_2 = 102;
+const int KILLER_MAX = 2;
 
 
 ////
@@ -55,10 +55,13 @@ const int PLY_MAX_PLUS_2 = 102;
 struct SearchStack {
   Move pv[PLY_MAX];
   Move currentMove;
-  Value currentMoveCaptureValue;
+  Move mateKiller;
-  Move mateKiller, killer1, killer2;
   Move threatMove;
+  Move killers[KILLER_MAX];
   Depth reduction;
+
+  void init(int ply);
+  void initKillers();
 };
 
 
@@ -66,14 +69,13 @@ struct SearchStack {
 //// Global variables
 ////
 
+extern SearchStack EmptySearchStack;
 extern TranspositionTable TT;
-
 extern int ActiveThreads;
-
 extern Lock SMPLock;
 
 // Perhaps better to make H local, and pass as parameter to MovePicker?
-extern History H;  
+extern History H;
 
 
 ////
@@ -83,7 +85,7 @@ extern History H;
 extern void init_threads();
 extern void stop_threads();
 extern void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
-                  int time[], int increment[], int movesToGo, int maxDepth, 
+                  int time[], int increment[], int movesToGo, int maxDepth,
                   int maxNodes, int maxTime, Move searchMoves[]);
 extern int64_t nodes_searched();
 

src/square.cpp

@@ -1,85 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
-
-  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.
-  
-  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.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include <cassert>
-#include <string>
-
-#include "square.h"
-
-
-////
-//// Functions
-////
-
-
-/// Translating files, ranks and squares to/from characters and strings:
-
-File file_from_char(char c) {
-  return File(c - 'a') + FILE_A;
-}
-
-
-char file_to_char(File f) {
-  return char(f - FILE_A) + 'a';
-}
-
-
-Rank rank_from_char(char c) {
-  return Rank(c - '1') + RANK_1;
-}
-
-
-char rank_to_char(Rank r) {
-  return char(r - RANK_1) + '1';
-}
-
-
-Square square_from_string(const std::string &str) {
-  return make_square(file_from_char(str[0]), rank_from_char(str[1]));
-}
-
-
-const std::string square_to_string(Square s) {
-  std::string str;
-  str += file_to_char(square_file(s));
-  str += rank_to_char(square_rank(s));
-  return str;
-}
-
-
-/// file_is_ok(), rank_is_ok() and square_is_ok(), for debugging:
-
-bool file_is_ok(File f) {
-  return f >= FILE_A && f <= FILE_H;
-}
-
-
-bool rank_is_ok(Rank r) {
-  return r >= RANK_1 && r <= RANK_8;
-}
-
-
-bool square_is_ok(Square s) {
-  return file_is_ok(square_file(s)) && rank_is_ok(square_rank(s));
-}

src/square.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -46,7 +46,7 @@ enum Square {
   SQ_A7, SQ_B7, SQ_C7, SQ_D7, SQ_E7, SQ_F7, SQ_G7, SQ_H7,
   SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8,
   SQ_NONE
-}; 
+};
 
 enum File {
   FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, FILE_NONE
@@ -73,7 +73,7 @@ const int FlipMask = 070;
 const int FlopMask = 07;
 
 
-//// 
+////
 //// Inline functions
 ////
 
@@ -159,21 +159,43 @@ inline int square_distance(Square s1, Square s2) {
   return Max(file_distance(s1, s2), rank_distance(s1, s2));
 }
 
+inline File file_from_char(char c) {
+  return File(c - 'a') + FILE_A;
+}
 
-//// 
+inline char file_to_char(File f) {
-//// Prototypes
+  return char(f - FILE_A + int('a'));
-////
+}
 
-extern File file_from_char(char c);
+inline Rank rank_from_char(char c) {
-extern char file_to_char(File f);
+  return Rank(c - '1') + RANK_1;
-extern Rank rank_from_char(char c);
+}
-extern char rank_to_char(Rank r);
-extern Square square_from_string(const std::string &str);
-extern const std::string square_to_string(Square s);
 
-extern bool file_is_ok(File f);
+inline char rank_to_char(Rank r) {
-extern bool rank_is_ok(Rank r);
+  return char(r - RANK_1 + int('1'));
-extern bool square_is_ok(Square s);
+}
 
+inline Square square_from_string(const std::string& str) {
+  return make_square(file_from_char(str[0]), rank_from_char(str[1]));
+}
+
+inline const std::string square_to_string(Square s) {
+  std::string str;
+  str += file_to_char(square_file(s));
+  str += rank_to_char(square_rank(s));
+  return str;
+}
+
+inline bool file_is_ok(File f) {
+  return f >= FILE_A && f <= FILE_H;
+}
+
+inline bool rank_is_ok(Rank r) {
+  return r >= RANK_1 && r <= RANK_8;
+}
+
+inline bool square_is_ok(Square s) {
+  return file_is_ok(square_file(s)) && rank_is_ok(square_rank(s));
+}
 
 #endif // !defined(SQUARE_H_INCLUDED)

src/thread.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

src/timeoday.cpp

@@ -1,28 +0,0 @@
-/*
-   (c) Copyright 1992 Eric Backus
-
-   This software may be used freely so long as this copyright notice is
-   left intact.  There is no warrantee on this software.
- */
-#include <windows.h>
-#include <time.h>
-#include "dos.h"
-
-
-int             gettimeofday(struct timeval * tp, struct timezone * tzp)
-{
-    SYSTEMTIME      systime;
-
-    if (tp) {
-        struct tm       tmrec;
-        time_t          theTime = time(NULL);
-
-
-        tmrec = *localtime(&theTime);
-        tp->tv_sec = mktime(&tmrec);
-        GetLocalTime(&systime); /* system time */
-
-        tp->tv_usec = systime.wMilliseconds * 1000;
-    }
-    return 0;
-}

src/tt.cpp

@@ -33,20 +33,13 @@
 //// Functions
 ////
 
-/// Constructor
+TranspositionTable::TranspositionTable() {
 
-TranspositionTable::TranspositionTable(unsigned mbSize) {
+  size = writes = 0;
-
-  size = 0;
-  generation = 0;
-  writes = 0;
   entries = 0;
-  set_size(mbSize);
+  generation = 0;
 }
 
-
-/// Destructor
-
 TranspositionTable::~TranspositionTable() {
 
   delete [] entries;
@@ -58,33 +51,33 @@ TranspositionTable::~TranspositionTable() {
 
 void TranspositionTable::set_size(unsigned mbSize) {
 
-  assert(mbSize >= 4 && mbSize <= 1024);
+  assert(mbSize >= 4 && mbSize <= 4096);
 
   unsigned newSize = 1024;
 
   // We store a cluster of 4 TTEntry for each position and newSize is
   // the maximum number of storable positions
-  for ( ; newSize * 4 * (sizeof(TTEntry)) <= (mbSize << 20); newSize *= 2);
+  while ((2 * newSize) * 4 * (sizeof(TTEntry)) <= (mbSize << 20))
-  newSize /= 2;
+      newSize *= 2;
+
   if (newSize != size)
   {
-    size = newSize;
+      size = newSize;
-    delete [] entries;
+      delete [] entries;
-    entries = new TTEntry[size * 4];
+      entries = new TTEntry[size * 4];
-    if (!entries)
+      if (!entries)
-    {
+      {
-      std::cerr << "Failed to allocate " << mbSize
+          std::cerr << "Failed to allocate " << mbSize
-                << " MB for transposition table."
+                    << " MB for transposition table." << std::endl;
-                << std::endl;
+          exit(EXIT_FAILURE);
-      exit(EXIT_FAILURE);
+      }
-    }
+      clear();
-    clear();
   }
 }
 
 
 /// TranspositionTable::clear overwrites the entire transposition table
-/// with zeroes.  It is called whenever the table is resized, or when the
+/// with zeroes. It is called whenever the table is resized, or when the
 /// user asks the program to clear the table (from the UCI interface).
 /// Perhaps we should also clear it when the "ucinewgame" command is recieved?
 
@@ -96,43 +89,44 @@ void TranspositionTable::clear() {
 
 /// TranspositionTable::store writes a new entry containing a position,
 /// a value, a value type, a search depth, and a best move to the
-/// transposition table.  The transposition table is organized in clusters
+/// transposition table. Transposition table is organized in clusters of
-/// of four TTEntry objects, and when a new entry is written, it replaces
+/// four TTEntry objects, and when a new entry is written, it replaces
-/// the least valuable of the four entries in a cluster.  A TTEntry t1 is
+/// the least valuable of the four entries in a cluster. A TTEntry t1 is
 /// considered to be more valuable than a TTEntry t2 if t1 is from the
 /// current search and t2 is from a previous search, or if the depth of t1
-/// is bigger than the depth of t2.
+/// is bigger than the depth of t2. A TTEntry of type VALUE_TYPE_EVAL
+/// never replaces another entry for the same position.
+
+void TranspositionTable::store(const Position& p, Value v, ValueType t, Depth d, Move m) {
 
-void TranspositionTable::store(const Position &pos, Value v, Depth d,
-                               Move m, ValueType type) {
   TTEntry *tte, *replace;
 
-  tte = replace = first_entry(pos);
+  tte = replace = first_entry(p);
-  for (int i = 0; i < 4; i++)
+  for (int i = 0; i < 4; i++, tte++)
   {
-    if (!(tte+i)->key()) // still empty
+      if (!tte->key() || tte->key() == p.get_key()) // empty or overwrite old
-    {
+      {
-        *(tte+i) = TTEntry(pos.get_key(), v, type, d, m, generation);
+          // Do not overwrite when new type is VALUE_TYPE_EVAL
-        writes++;
+          if (tte->key() && t == VALUE_TYPE_EVAL)
-        return;
+              return;
-    }
-    if ((tte+i)->key() == pos.get_key()) // overwrite old
-    {
-        if (m == MOVE_NONE)
-            m = (tte+i)->move();
 
-        *(tte+i) = TTEntry(pos.get_key(), v, type, d, m, generation);
+          if (m == MOVE_NONE)
-        return;
+              m = tte->move();
-    }
-    if (   i == 0  // already is (replace == tte+i), common case
-        || replace->generation() < (tte+i)->generation())
-        continue;
 
-    if (    replace->generation() > (tte+i)->generation()
+          *tte = TTEntry(p.get_key(), v, t, d, m, generation);
-        || (tte+i)->depth() < replace->depth())
+          return;
-        replace = tte+i;
+      }
+      else if (i == 0)  // replace would be a no-op in this common case
+          continue;
+
+      int c1 = (replace->generation() == generation ?  2 : 0);
+      int c2 = (tte->generation() == generation ? -2 : 0);
+      int c3 = (tte->depth() < replace->depth() ?  1 : 0);
+
+      if (c1 + c2 + c3 > 0)
+          replace = tte;
   }
-  *replace = TTEntry(pos.get_key(), v, type, d, m, generation);
+  *replace = TTEntry(p.get_key(), v, t, d, m, generation);
   writes++;
 }
 
@@ -141,15 +135,14 @@ void TranspositionTable::store(const Position &pos, Value v, Depth d,
 /// transposition table. Returns a pointer to the TTEntry or NULL
 /// if position is not found.
 
-const TTEntry* TranspositionTable::retrieve(const Position &pos) const {
+TTEntry* TranspositionTable::retrieve(const Position& pos) const {
 
   TTEntry *tte = first_entry(pos);
 
   for (int i = 0; i < 4; i++, tte++)
-  {
       if (tte->key() == pos.get_key())
           return tte;
-  }
+
   return NULL;
 }
 
@@ -157,13 +150,13 @@ const TTEntry* TranspositionTable::retrieve(const Position &pos) const {
 /// TranspositionTable::first_entry returns a pointer to the first
 /// entry of a cluster given a position.
 
-inline TTEntry* TranspositionTable::first_entry(const Position &pos) const {
+inline TTEntry* TranspositionTable::first_entry(const Position& pos) const {
 
   return entries + (int(pos.get_key() & (size - 1)) << 2);
 }
 
 /// TranspositionTable::new_search() is called at the beginning of every new
-/// search.  It increments the "generation" variable, which is used to
+/// search. It increments the "generation" variable, which is used to
 /// distinguish transposition table entries from previous searches from
 /// entries from the current search.
 
@@ -175,19 +168,19 @@ void TranspositionTable::new_search() {
 
 
 /// TranspositionTable::insert_pv() is called at the end of a search
-/// iteration, and inserts the PV back into the PV.  This makes sure the
+/// iteration, and inserts the PV back into the PV. This makes sure
-/// old PV moves are searched first, even if the old TT entries have been
+/// the old PV moves are searched first, even if the old TT entries
-/// overwritten.
+/// have been overwritten.
 
-void TranspositionTable::insert_pv(const Position &pos, Move pv[]) {
+void TranspositionTable::insert_pv(const Position& pos, Move pv[]) {
 
-  UndoInfo u;
+  StateInfo st;
   Position p(pos);
 
   for (int i = 0; pv[i] != MOVE_NONE; i++)
   {
-    store(p, VALUE_NONE, Depth(0), pv[i], VALUE_TYPE_NONE);
+      store(p, VALUE_NONE, VALUE_TYPE_NONE, Depth(-127*OnePly), pv[i]);
-    p.do_move(pv[i], u);
+      p.do_move(pv[i], st);
   }
 }
 
@@ -196,22 +189,8 @@ void TranspositionTable::insert_pv(const Position &pos, Move pv[]) {
 /// entries which have received at least one write during the current search.
 /// It is used to display the "info hashfull ..." information in UCI.
 
-int TranspositionTable::full() {
+int TranspositionTable::full() const {
 
   double N = double(size) * 4.0;
   return int(1000 * (1 - exp(writes * log(1.0 - 1.0/N))));
 }
-
-
-/// Constructors
-
-TTEntry::TTEntry() {
-}
-
-TTEntry::TTEntry(Key k, Value v, ValueType t, Depth d, Move m,
-                 int generation) :
-  key_ (k), data((m & 0x7FFFF) | (t << 20) | (generation << 23)),
-  value_(v), depth_(int16_t(d)) {}
-
-
-

src/tt.h

@@ -34,18 +34,35 @@
 //// Types
 ////
 
-/// The TTEntry class is the class of transposition table entries.
+/// The TTEntry class is the class of transposition table entries
+///
+/// A TTEntry needs 128 bits to be stored
+///
+/// bit    0-63: key
+/// bit   64-95: data
+/// bit  96-111: value
+/// bit 112-127: depth
+///
+/// the 32 bits of the data field are so defined
+///
+/// bit  0-16: move
+/// bit 17-19: not used
+/// bit 20-22: value type
+/// bit 23-31: generation
 
 class TTEntry {
 
 public:
-  TTEntry();
+  TTEntry() {}
-  TTEntry(Key k, Value v, ValueType t, Depth d, Move m, int generation);
+  TTEntry(Key k, Value v, ValueType t, Depth d, Move m, int generation)
+        : key_ (k), data((m & 0x1FFFF) | (t << 20) | (generation << 23)),
+          value_(int16_t(v)), depth_(int16_t(d)) {}
+
   Key key() const { return key_; }
   Depth depth() const { return Depth(depth_); }
-  Move move() const { return Move(data & 0x7FFFF); }
+  Move move() const { return Move(data & 0x1FFFF); }
   Value value() const { return Value(value_); }
-  ValueType type() const { return ValueType((data >> 20) & 3); }
+  ValueType type() const { return ValueType((data >> 20) & 7); }
   int generation() const { return (data >> 23); }
 
 private:
@@ -62,32 +79,22 @@ private:
 class TranspositionTable {
 
 public:
-  TranspositionTable(unsigned mbSize);
+  TranspositionTable();
   ~TranspositionTable();
   void set_size(unsigned mbSize);
   void clear();
-  void store(const Position &pos, Value v, Depth d, Move m, ValueType type);
+  void store(const Position& pos, Value v, ValueType type, Depth d, Move m);
-  const TTEntry* retrieve(const Position &pos) const;
+  TTEntry* retrieve(const Position& pos) const;
   void new_search();
-  void insert_pv(const Position &pos, Move pv[]);
+  void insert_pv(const Position& pos, Move pv[]);
-  int full();
+  int full() const;
 
 private:
-  inline TTEntry* first_entry(const Position &pos) const;
+  inline TTEntry* first_entry(const Position& pos) const;
 
-  unsigned size;
+  unsigned size, writes;
-  int writes;
   TTEntry* entries;
   uint8_t generation;
 };
 
-
-////
-//// Constants and variables
-////
-
-// Default transposition table size, in megabytes:
-const int TTDefaultSize = 32;
-
-
 #endif // !defined(TT_H_INCLUDED)

src/types.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

src/uci.cpp

@@ -22,6 +22,7 @@
 //// Includes
 ////
 
+#include <cassert>
 #include <iostream>
 #include <sstream>
 #include <string>
@@ -169,7 +170,7 @@ namespace {
     }
     else if (token == "key")
     {
-        std::cout << "key: " << RootPosition.get_key()
+        std::cout << "key: " << std::hex << RootPosition.get_key()
                   << " material key: " << RootPosition.get_material_key()
                   << " pawn key: " << RootPosition.get_pawn_key()
                   << std::endl;
@@ -219,15 +220,18 @@ namespace {
         if (token == "moves")
         {
             Move move;
-            UndoInfo u;
+            StateInfo st;
             while (!uip.eof())
             {
                 uip >> token;
                 move = move_from_string(RootPosition, token);
-                RootPosition.do_move(move, u);
+                RootPosition.do_move(move, st);
                 if (RootPosition.rule_50_counter() == 0)
                     RootPosition.reset_game_ply();
             }
+            // Our StateInfo st is about going out of scope,
+            // so save its content before they disappear.
+            RootPosition.setStartState(st);
         }
     }
   }
@@ -247,11 +251,13 @@ namespace {
     if (token == "name")
     {
         uip >> name;
-        uip >> token;
+        while (!uip.eof())
-        while (!uip.eof() && token != "value")
         {
-          name += (" " + token);
+            uip >> token;
-          uip >> token;
+            if (token == "value")
+                break;
+
+            name += (" " + token);
         }
         if (token == "value")
         {
@@ -321,6 +327,8 @@ namespace {
     if (moveTime)
         infinite = true;  // HACK
 
+    assert(RootPosition.is_ok());
+
     think(RootPosition, infinite, ponder, RootPosition.side_to_move(), time,
           inc, movesToGo, depth, nodes, moveTime, searchMoves);
   }

src/uci.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

src/ucioption.cpp

@@ -22,7 +22,9 @@
 //// Includes
 ////
 
+#include <algorithm>
 #include <cassert>
+#include <map>
 #include <string>
 #include <sstream>
 #include <vector>
@@ -36,7 +38,7 @@
 //// Variables
 ////
 
-bool Chess960 = false;
+bool Chess960;
 
 
 ////
@@ -57,90 +59,92 @@ namespace {
 
     std::string name, defaultValue, currentValue;
     OptionType type;
+    size_t idx;
     int minValue, maxValue;
     ComboValues comboValues;
 
-    Option(const char* name, const char* defaultValue, OptionType = STRING);
+    Option();
-    Option(const char* name, bool defaultValue, OptionType = CHECK);
+    Option(const char* defaultValue, OptionType = STRING);
-    Option(const char* name, int defaultValue, int minValue, int maxValue);
+    Option(bool defaultValue, OptionType = CHECK);
+    Option(int defaultValue, int minValue, int maxValue);
+
+    bool operator<(const Option& o) const { return this->idx < o.idx; }
   };
 
-  typedef std::vector<Option> Options;
+  typedef std::map<std::string, Option> Options;
 
   ///
   /// Constants
   ///
 
-  // load_defaults populates the options vector with the hard
+  // load_defaults populates the options map with the hard
   // coded names and default values.
 
   void load_defaults(Options& o) {
 
-    o.push_back(Option("Use Search Log", false));
+    o["Use Search Log"] = Option(false);
-    o.push_back(Option("Search Log Filename", "SearchLog.txt"));
+    o["Search Log Filename"] = Option("SearchLog.txt");
-    o.push_back(Option("Book File", "book.bin"));
+    o["Book File"] = Option("book.bin");
-    o.push_back(Option("Mobility (Middle Game)", 100, 0, 200));
+    o["Mobility (Middle Game)"] = Option(100, 0, 200);
-    o.push_back(Option("Mobility (Endgame)", 100, 0, 200));
+    o["Mobility (Endgame)"] = Option(100, 0, 200);
-    o.push_back(Option("Pawn Structure (Middle Game)", 100, 0, 200));
+    o["Pawn Structure (Middle Game)"] = Option(100, 0, 200);
-    o.push_back(Option("Pawn Structure (Endgame)", 100, 0, 200));
+    o["Pawn Structure (Endgame)"] = Option(100, 0, 200);
-    o.push_back(Option("Passed Pawns (Middle Game)", 100, 0, 200));
+    o["Passed Pawns (Middle Game)"] = Option(100, 0, 200);
-    o.push_back(Option("Passed Pawns (Endgame)", 100, 0, 200));
+    o["Passed Pawns (Endgame)"] = Option(100, 0, 200);
-    o.push_back(Option("Aggressiveness", 100, 0, 200));
+    o["Space"] = Option(100, 0, 200);
-    o.push_back(Option("Cowardice", 100, 0, 200));
+    o["Aggressiveness"] = Option(100, 0, 200);
-    o.push_back(Option("King Safety Curve", "Quadratic", COMBO));
+    o["Cowardice"] = Option(100, 0, 200);
+    o["King Safety Curve"] = Option("Quadratic", COMBO);
 
-       o.back().comboValues.push_back("Quadratic");
+       o["King Safety Curve"].comboValues.push_back("Quadratic");
-       o.back().comboValues.push_back("Linear");  /*, "From File"*/
+       o["King Safety Curve"].comboValues.push_back("Linear");  /*, "From File"*/
 
-    o.push_back(Option("King Safety Coefficient", 40, 1, 100));
+    o["King Safety Coefficient"] = Option(40, 1, 100);
-    o.push_back(Option("King Safety X Intercept", 0, 0, 20));
+    o["King Safety X Intercept"] = Option(0, 0, 20);
-    o.push_back(Option("King Safety Max Slope", 30, 10, 100));
+    o["King Safety Max Slope"] = Option(30, 10, 100);
-    o.push_back(Option("King Safety Max Value", 500, 100, 1000));
+    o["King Safety Max Value"] = Option(500, 100, 1000);
-    o.push_back(Option("Queen Contact Check Bonus", 4, 0, 8));
+    o["Queen Contact Check Bonus"] = Option(3, 0, 8);
-    o.push_back(Option("Rook Contact Check Bonus", 2, 0, 4));
+    o["Queen Check Bonus"] = Option(2, 0, 4);
-    o.push_back(Option("Queen Check Bonus", 2, 0, 4));
+    o["Rook Check Bonus"] = Option(1, 0, 4);
-    o.push_back(Option("Rook Check Bonus", 1, 0, 4));
+    o["Bishop Check Bonus"] = Option(1, 0, 4);
-    o.push_back(Option("Bishop Check Bonus", 1, 0, 4));
+    o["Knight Check Bonus"] = Option(1, 0, 4);
-    o.push_back(Option("Knight Check Bonus", 1, 0, 4));
+    o["Discovered Check Bonus"] = Option(3, 0, 8);
-    o.push_back(Option("Discovered Check Bonus", 3, 0, 8));
+    o["Mate Threat Bonus"] = Option(3, 0, 8);
-    o.push_back(Option("Mate Threat Bonus", 3, 0, 8));
+    o["Check Extension (PV nodes)"] = Option(2, 0, 2);
-    o.push_back(Option("Check Extension (PV nodes)", 2, 0, 2));
+    o["Check Extension (non-PV nodes)"] = Option(1, 0, 2);
-    o.push_back(Option("Check Extension (non-PV nodes)", 1, 0, 2));
+    o["Single Reply Extension (PV nodes)"] = Option(2, 0, 2);
-    o.push_back(Option("Single Reply Extension (PV nodes)", 2, 0, 2));
+    o["Single Reply Extension (non-PV nodes)"] = Option(2, 0, 2);
-    o.push_back(Option("Single Reply Extension (non-PV nodes)", 2, 0, 2));
+    o["Mate Threat Extension (PV nodes)"] = Option(0, 0, 2);
-    o.push_back(Option("Mate Threat Extension (PV nodes)", 0, 0, 2));
+    o["Mate Threat Extension (non-PV nodes)"] = Option(0, 0, 2);
-    o.push_back(Option("Mate Threat Extension (non-PV nodes)", 0, 0, 2));
+    o["Pawn Push to 7th Extension (PV nodes)"] = Option(1, 0, 2);
-    o.push_back(Option("Pawn Push to 7th Extension (PV nodes)", 1, 0, 2));
+    o["Pawn Push to 7th Extension (non-PV nodes)"] = Option(1, 0, 2);
-    o.push_back(Option("Pawn Push to 7th Extension (non-PV nodes)", 1, 0, 2));
+    o["Passed Pawn Extension (PV nodes)"] = Option(1, 0, 2);
-    o.push_back(Option("Passed Pawn Extension (PV nodes)", 1, 0, 2));
+    o["Passed Pawn Extension (non-PV nodes)"] = Option(0, 0, 2);
-    o.push_back(Option("Passed Pawn Extension (non-PV nodes)", 0, 0, 2));
+    o["Pawn Endgame Extension (PV nodes)"] = Option(2, 0, 2);
-    o.push_back(Option("Pawn Endgame Extension (PV nodes)", 2, 0, 2));
+    o["Pawn Endgame Extension (non-PV nodes)"] = Option(2, 0, 2);
-    o.push_back(Option("Pawn Endgame Extension (non-PV nodes)", 2, 0, 2));
+    o["Full Depth Moves (PV nodes)"] = Option(14, 1, 100);
-    o.push_back(Option("Full Depth Moves (PV nodes)", 14, 1, 100));
+    o["Full Depth Moves (non-PV nodes)"] = Option(3, 1, 100);
-    o.push_back(Option("Full Depth Moves (non-PV nodes)", 3, 1, 100));
+    o["Threat Depth"] = Option(5, 0, 100);
-    o.push_back(Option("Threat Depth", 5, 0, 100));
+    o["Futility Pruning (Main Search)"] = Option(true);
-    o.push_back(Option("Selective Plies", 7, 0, 10));
+    o["Futility Pruning (Quiescence Search)"] = Option(true);
-    o.push_back(Option("Futility Pruning (Main Search)", true));
+    o["LSN filtering"] = Option(false);
-    o.push_back(Option("Futility Pruning (Quiescence Search)", true));
+    o["LSN Time Margin (sec)"] = Option(4, 1, 10);
-    o.push_back(Option("Futility Margin 0", 50, 0, 1000));
+    o["LSN Value Margin"] = Option(200, 100, 600);
-    o.push_back(Option("Futility Margin 1", 100, 0, 1000));
+    o["Randomness"] = Option(0, 0, 10);
-    o.push_back(Option("Futility Margin 2", 300, 0, 1000));
+    o["Minimum Split Depth"] = Option(4, 4, 7);
-    o.push_back(Option("Maximum Razoring Depth", 3, 0, 4));
+    o["Maximum Number of Threads per Split Point"] = Option(5, 4, 8);
-    o.push_back(Option("Razoring Margin", 300, 150, 600));
+    o["Threads"] = Option(1, 1, 8);
-    o.push_back(Option("LSN filtering", false));
+    o["Hash"] = Option(32, 4, 4096);
-    o.push_back(Option("LSN Time Margin (sec)", 4, 1, 10));
+    o["Clear Hash"] = Option(false, BUTTON);
-    o.push_back(Option("LSN Value Margin", 200, 100, 600));
+    o["Ponder"] = Option(true);
-    o.push_back(Option("Randomness", 0, 0, 10));
+    o["OwnBook"] = Option(true);
-    o.push_back(Option("Minimum Split Depth", 4, 4, 7));
+    o["MultiPV"] = Option(1, 1, 500);
-    o.push_back(Option("Maximum Number of Threads per Split Point", 5, 4, 8));
+    o["UCI_ShowCurrLine"] = Option(false);
-    o.push_back(Option("Threads", 1, 1, 8));
+    o["UCI_Chess960"] = Option(false);
-    o.push_back(Option("Hash", 32, 4, 4096));
+
-    o.push_back(Option("Clear Hash", false, BUTTON));
+    // Any option should know its name so to be easily printed
-    o.push_back(Option("Ponder", true));
+    for (Options::iterator it = o.begin(); it != o.end(); ++it)
-    o.push_back(Option("OwnBook", true));
+        it->second.name = it->first;
-    o.push_back(Option("MultiPV", 1, 1, 500));
-    o.push_back(Option("UCI_ShowCurrLine", false));
-    o.push_back(Option("UCI_Chess960", false));
   }
 
   ///
@@ -149,9 +153,6 @@ namespace {
 
   Options options;
 
-  // Local functions
-  Options::iterator option_with_name(const std::string& optionName);
-
   // stringify converts a value of type T to a std::string
   template<typename T>
   std::string stringify(const T& v) {
@@ -161,13 +162,6 @@ namespace {
      return ss.str();
   }
 
-  // We want conversion from a bool value to be "true" or "false",
-  // not "1" or "0", so add a specialization for bool type.
-  template<>
-  std::string stringify<bool>(const bool& v) {
-
-    return v ? "true" : "false";
-  }
 
   // get_option_value implements the various get_option_value_<type>
   // functions defined later, because only the option value
@@ -176,29 +170,15 @@ namespace {
   template<typename T>
   T get_option_value(const std::string& optionName) {
 
-      T ret;
+      T ret = T();
-      Options::iterator it = option_with_name(optionName);
+      if (options.find(optionName) == options.end())
+          return ret;
 
-      if (it != options.end())
+      std::istringstream ss(options[optionName].currentValue);
-      {
+      ss >> ret;
-          std::istringstream ss(it->currentValue);
-          ss >> ret;
-      }
       return ret;
   }
 
-  // Unfortunatly we need a specialization to convert "false" and "true"
-  // to proper bool values. The culprit is that we use a non standard way
-  // to store a bool value in a string, in particular we use "false" and
-  // "true" instead of "0" and "1" due to how UCI protocol works.
-
-  template<>
-  bool get_option_value<bool>(const std::string& optionName) {
-
-      Options::iterator it = option_with_name(optionName);
-
-      return it != options.end() && it->currentValue == "true";
-  }
 }
 
 ////
@@ -217,24 +197,19 @@ void init_uci_options() {
   // According to Ken Dail's tests, Glaurung plays much better with 7 than
   // with 8 threads.  This is weird, but it is probably difficult to find out
   // why before I have a 8-core computer to experiment with myself.
-  Options::iterator it = option_with_name("Threads");
+  assert(options.find("Threads") != options.end());
+  assert(options.find("Minimum Split Depth") != options.end());
 
-  assert(it != options.end());
+  options["Threads"].defaultValue = stringify(Min(cpu_count(), 7));
-
+  options["Threads"].currentValue = stringify(Min(cpu_count(), 7));
-  it->defaultValue = stringify(Min(cpu_count(), 7));
-  it->currentValue = stringify(Min(cpu_count(), 7));
 
   // Increase the minimum split depth when the number of CPUs is big.
   // It would probably be better to let this depend on the number of threads
   // instead.
-  if(cpu_count() > 4)
+  if (cpu_count() > 4)
   {
-      it = option_with_name("Minimum Split Depth");
+      options["Minimum Split Depth"].defaultValue = "6";
-
+      options["Minimum Split Depth"].currentValue = "6";
-      assert(it != options.end());
-
-      it->defaultValue = "6";
-      it->currentValue = "6";
   }
 }
 
@@ -248,28 +223,40 @@ void print_uci_options() {
     "spin", "combo", "check", "string", "button"
   };
 
-  for (Options::iterator it = options.begin(); it != options.end(); ++it)
+  // Build up a vector out of the options map and sort it according to idx
-  {
+  // field, that is the chronological insertion order in options map.
-      std::cout << "option name " << it->name
+  std::vector<Option> vec;
-                << " type "       << optionTypeName[it->type];
+  for (Options::const_iterator it = options.begin(); it != options.end(); ++it)
+      vec.push_back(it->second);
 
-      if (it->type != BUTTON)
+  std::sort(vec.begin(), vec.end());
-      {
+
+  for (std::vector<Option>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+  {
+      std::cout << "\noption name " << it->name
+                << " type "         << optionTypeName[it->type];
+
+      if (it->type == BUTTON)
+          continue;
+
+      if (it->type == CHECK)
+          std::cout << " default " << (it->defaultValue == "1" ? "true" : "false");
+      else
           std::cout << " default " << it->defaultValue;
 
-          if (it->type == SPIN)
+      if (it->type == SPIN)
-              std::cout << " min " << it->minValue
+          std::cout << " min " << it->minValue
-                        << " max " << it->maxValue;
+                    << " max " << it->maxValue;
 
-          else if (it->type == COMBO)
+      else if (it->type == COMBO)
-              for(ComboValues::iterator itc = it->comboValues.begin();
+          for (ComboValues::const_iterator itc = it->comboValues.begin();
-                  itc != it->comboValues.end(); ++itc)
+              itc != it->comboValues.end(); ++itc)
-                      std::cout << " var " << *itc;
+              std::cout << " var " << *itc;
-      }
-      std::cout << std::endl;
   }
+  std::cout << std::endl;
 }
 
+
 /// get_option_value_bool() returns the current value of a UCI parameter of
 /// type "check".
 
@@ -291,7 +278,7 @@ int get_option_value_int(const std::string& optionName) {
 
 
 /// get_option_value_string() returns the current value of a UCI parameter as
-/// a string.  It is used with parameters of type "combo" and "string".
+/// a string. It is used with parameters of type "combo" and "string".
 
 const std::string get_option_value_string(const std::string& optionName) {
 
@@ -299,32 +286,23 @@ const std::string get_option_value_string(const std::string& optionName) {
 }
 
 
-/// button_was_pressed() tests whether a UCI parameter of type "button" has
+/// set_option_value() inserts a new value for a UCI parameter. Note that
-/// been selected since the last time the function was called.
-
-bool button_was_pressed(const std::string& buttonName) {
-
-  if (get_option_value<bool>(buttonName))
-  {
-    set_option_value(buttonName, "false");
-    return true;
-  }
-
-  return false;
-}
-
-
-/// set_option_value() inserts a new value for a UCI parameter.  Note that
 /// the function does not check that the new value is legal for the given
-/// parameter:  This is assumed to be the responsibility of the GUI.
+/// parameter: This is assumed to be the responsibility of the GUI.
 
 void set_option_value(const std::string& optionName,
                       const std::string& newValue) {
 
-  Options::iterator it = option_with_name(optionName);
+  // UCI protocol uses "true" and "false" instead of "1" and "0", so convert
+  // newValue according to standard C++ convention before to store it.
+  std::string v(newValue);
+  if (v == "true")
+      v = "1";
+  else if (v == "false")
+      v = "0";
 
-  if (it != options.end())
+  if (options.find(optionName) != options.end())
-      it->currentValue = newValue;
+      options[optionName].currentValue = v;
   else
       std::cout << "No such option: " << optionName << std::endl;
 }
@@ -339,29 +317,33 @@ void push_button(const std::string& buttonName) {
 }
 
 
+/// button_was_pressed() tests whether a UCI parameter of type "button" has
+/// been selected since the last time the function was called, in this case
+/// it also resets the button.
+
+bool button_was_pressed(const std::string& buttonName) {
+
+  if (!get_option_value<bool>(buttonName))
+	  return false;
+
+  set_option_value(buttonName, "false");
+  return true;
+}
+
+
 namespace {
 
-    // Define constructors of Option class.
+  // Define constructors of Option class.
 
-    Option::Option(const char* nm, const char* def, OptionType t)
+  Option::Option() {} // To allow insertion in a std::map
-    : name(nm), defaultValue(def), currentValue(def), type(t), minValue(0), maxValue(0) {}
 
-    Option::Option(const char* nm, bool def, OptionType t)
+  Option::Option(const char* def, OptionType t)
-    : name(nm), defaultValue(stringify(def)), currentValue(stringify(def)), type(t), minValue(0), maxValue(0) {}
+  : defaultValue(def), currentValue(def), type(t), idx(options.size()), minValue(0), maxValue(0) {}
 
-    Option::Option(const char* nm, int def, int minv, int maxv)
+  Option::Option(bool def, OptionType t)
-    : name(nm), defaultValue(stringify(def)), currentValue(stringify(def)), type(SPIN), minValue(minv), maxValue(maxv) {}
+  : defaultValue(stringify(def)), currentValue(stringify(def)), type(t), idx(options.size()), minValue(0), maxValue(0) {}
 
-    // option_with_name() tries to find a UCI option with a given
+  Option::Option(int def, int minv, int maxv)
-    // name.  It returns an iterator to the UCI option or to options.end(),
+  : defaultValue(stringify(def)), currentValue(stringify(def)), type(SPIN), idx(options.size()), minValue(minv), maxValue(maxv) {}
-    // depending on whether an option with the given name exists.
 
-    Options::iterator option_with_name(const std::string& optionName) {
-
-        for (Options::iterator it = options.begin(); it != options.end(); ++it)
-            if (it->name == optionName)
-                return it;
-
-        return options.end();
-    }
 }

src/ucioption.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -45,7 +45,7 @@ extern bool get_option_value_bool(const std::string &optionName);
 extern int get_option_value_int(const std::string &optionName);
 extern const std::string get_option_value_string(const std::string &optionName);
 extern bool button_was_pressed(const std::string &buttonName);
-extern void set_option_value(const std::string &optionName, 
+extern void set_option_value(const std::string &optionName,
                              const std::string &newValue);
 extern void push_button(const std::string &buttonName);
 

src/value.cpp

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

src/value.h

@@ -7,12 +7,12 @@
   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.
-  
+
   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.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -36,7 +36,8 @@ enum ValueType {
   VALUE_TYPE_NONE = 0,
   VALUE_TYPE_UPPER = 1,  // Upper bound
   VALUE_TYPE_LOWER = 2,  // Lower bound
-  VALUE_TYPE_EXACT = 3   // Exact score
+  VALUE_TYPE_EXACT = 3,  // Exact score
+  VALUE_TYPE_EVAL  = 4   // Evaluation cache
 };
 
 
@@ -58,17 +59,19 @@ enum Value {
 /// Important: If the material values are changed, one must also
 /// adjust the piece square tables, and the method game_phase() in the
 /// Position class!
+///
+/// Values modified by Joona Kiiski
 
-const Value PawnValueMidgame = Value(0xCC);
+const Value PawnValueMidgame   = Value(0x0CC);
-const Value PawnValueEndgame = Value(0x100);
+const Value PawnValueEndgame   = Value(0x101);
-const Value KnightValueMidgame = Value(0x340);
+const Value KnightValueMidgame = Value(0x332);
-const Value KnightValueEndgame = Value(0x340);
+const Value KnightValueEndgame = Value(0x34E);
-const Value BishopValueMidgame = Value(0x340);
+const Value BishopValueMidgame = Value(0x345);
-const Value BishopValueEndgame = Value(0x340);
+const Value BishopValueEndgame = Value(0x356);
-const Value RookValueMidgame = Value(0x505);
+const Value RookValueMidgame   = Value(0x4F8);
-const Value RookValueEndgame = Value(0x505);
+const Value RookValueEndgame   = Value(0x500);
-const Value QueenValueMidgame = Value(0xA00);
+const Value QueenValueMidgame  = Value(0x9D5);
-const Value QueenValueEndgame = Value(0xA00);
+const Value QueenValueEndgame  = Value(0x9FB);
 
 const Value PieceValueMidgame[17] = {
   Value(0),
@@ -92,8 +95,8 @@ const Value PieceValueEndgame[17] = {
 
 /// Bonus for having the side to move
 
-const Value TempoValueMidgame = Value(50);
+const Value TempoValueMidgame = Value(48);
-const Value TempoValueEndgame = Value(20);
+const Value TempoValueEndgame = Value(21);
 
 
 ////
@@ -121,7 +124,7 @@ inline void operator/= (Value &v, int i) { v = Value(int(v) / i); }
 inline Value value_mate_in(int ply) {
   return Value(VALUE_MATE - Value(ply));
 }
-               
+
 inline Value value_mated_in(int ply) {
   return Value(-VALUE_MATE + Value(ply));
 }