X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmovegen.cpp;h=dd849c15604813c9ba6acf005d807fa4e508f682;hp=5b8f2e9a8a1103410b740488cf2f88d793c72f25;hb=9c7d72739cffe523f0ea8c84875160c17ae6ab82;hpb=f5e434c2d91cf1a43ee64dfc68318024ffaf7656

diff --git a/src/movegen.cpp b/src/movegen.cpp
index 5b8f2e9a..dd849c15 100644
--- a/src/movegen.cpp
+++ b/src/movegen.cpp
@@ -18,9 +18,11 @@
 */
 
 #include <cassert>
+#include <algorithm>
 
 #include "bitcount.h"
 #include "movegen.h"
+#include "position.h"
 
 // Simple macro to wrap a very common while loop, no facny, no flexibility,
 // hardcoded list name 'mlist' and from square 'from'.
@@ -51,7 +53,7 @@ namespace {
     Bitboard b = pos.attacks_from<Pt>(from) & pos.empty_squares();
 
     if (Pt == KING)
-        b &= ~QueenPseudoAttacks[pos.king_square(opposite_color(pos.side_to_move()))];
+        b &= ~QueenPseudoAttacks[pos.king_square(flip(pos.side_to_move()))];
 
     SERIALIZE_MOVES(b);
     return mlist;
@@ -151,14 +153,13 @@ namespace {
 template<MoveType Type>
 MoveStack* generate(const Position& pos, MoveStack* mlist) {
 
-  assert(pos.is_ok());
   assert(!pos.in_check());
 
   Color us = pos.side_to_move();
   Bitboard target;
 
   if (Type == MV_CAPTURE || Type == MV_NON_EVASION)
-      target = pos.pieces(opposite_color(us));
+      target = pos.pieces(flip(us));
   else if (Type == MV_NON_CAPTURE)
       target = pos.empty_squares();
   else
@@ -202,23 +203,22 @@ template MoveStack* generate<MV_NON_EVASION>(const Position& pos, MoveStack* mli
 template<>
 MoveStack* generate<MV_NON_CAPTURE_CHECK>(const Position& pos, MoveStack* mlist) {
 
-  assert(pos.is_ok());
   assert(!pos.in_check());
 
   Bitboard b, dc;
   Square from;
   Color us = pos.side_to_move();
-  Square ksq = pos.king_square(opposite_color(us));
+  Square ksq = pos.king_square(flip(us));
 
-  assert(pos.piece_on(ksq) == make_piece(opposite_color(us), KING));
+  assert(pos.piece_on(ksq) == make_piece(flip(us), KING));
 
   // Discovered non-capture checks
-  b = dc = pos.discovered_check_candidates(us);
+  b = dc = pos.discovered_check_candidates();
 
   while (b)
   {
      from = pop_1st_bit(&b);
-     switch (piece_type(pos.piece_on(from)))
+     switch (type_of(pos.piece_on(from)))
      {
       case PAWN:   /* Will be generated togheter with pawns direct checks */     break;
       case KNIGHT: mlist = generate_discovered_checks<KNIGHT>(pos, mlist, from); break;
@@ -243,7 +243,6 @@ MoveStack* generate<MV_NON_CAPTURE_CHECK>(const Position& pos, MoveStack* mlist)
 template<>
 MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
 
-  assert(pos.is_ok());
   assert(pos.in_check());
 
   Bitboard b, target;
@@ -266,9 +265,9 @@ MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
       checkersCnt++;
       checksq = pop_1st_bit(&b);
 
-      assert(piece_color(pos.piece_on(checksq)) == opposite_color(us));
+      assert(color_of(pos.piece_on(checksq)) == flip(us));
 
-      switch (piece_type(pos.piece_on(checksq)))
+      switch (type_of(pos.piece_on(checksq)))
       {
       case BISHOP: sliderAttacks |= BishopPseudoAttacks[checksq]; break;
       case ROOK:   sliderAttacks |= RookPseudoAttacks[checksq];   break;
@@ -315,10 +314,8 @@ MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
 template<>
 MoveStack* generate<MV_LEGAL>(const Position& pos, MoveStack* mlist) {
 
-  assert(pos.is_ok());
-
   MoveStack *last, *cur = mlist;
-  Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
+  Bitboard pinned = pos.pinned_pieces();
 
   last = pos.in_check() ? generate<MV_EVASION>(pos, mlist)
                         : generate<MV_NON_EVASION>(pos, mlist);
@@ -477,8 +474,8 @@ namespace {
     // En passant captures
     if ((Type == MV_CAPTURE || Type == MV_EVASION) && pos.ep_square() != SQ_NONE)
     {
-        assert(Us != WHITE || square_rank(pos.ep_square()) == RANK_6);
-        assert(Us != BLACK || square_rank(pos.ep_square()) == RANK_3);
+        assert(Us != WHITE || rank_of(pos.ep_square()) == RANK_6);
+        assert(Us != BLACK || rank_of(pos.ep_square()) == RANK_3);
 
         // An en passant capture can be an evasion only if the checking piece
         // is the double pushed pawn and so is in the target. Otherwise this
@@ -493,7 +490,7 @@ namespace {
         while (b1)
         {
             to = pop_1st_bit(&b1);
-            (*mlist++).move = make_ep_move(to, pos.ep_square());
+            (*mlist++).move = make_enpassant_move(to, pos.ep_square());
         }
     }
     return mlist;
@@ -503,7 +500,7 @@ namespace {
   MoveStack* generate_castle_moves(const Position& pos, MoveStack* mlist, Color us) {
 
     CastleRight f = CastleRight((Side == KING_SIDE ? WHITE_OO : WHITE_OOO) << us);
-    Color them = opposite_color(us);
+    Color them = flip(us);
 
     // After castling, the rook and king's final positions are exactly the same
     // in Chess960 as they would be in standard chess.
@@ -520,12 +517,12 @@ namespace {
     // (including the final square), and all the squares between the rook's initial
     // and final squares (including the final square), must be vacant except for
     // the king and castling rook.
-    for (Square s = Min(kfrom, kto); s <= Max(kfrom, kto); s++)
+    for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++)
         if (  (s != kfrom && s != rfrom && !pos.square_is_empty(s))
             ||(pos.attackers_to(s) & pos.pieces(them)))
             return mlist;
 
-    for (Square s = Min(rfrom, rto); s <= Max(rfrom, rto); s++)
+    for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++)
         if (s != kfrom && s != rfrom && !pos.square_is_empty(s))
             return mlist;