WebSVN – Games.Chess Giants – Diff – //engine-crafty/make.c

 #include "chess.h"
 #include "data.h"
-/* last modified 02/22/14 */
+/* last modified 01/06/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   MakeMove() is responsible for updating the position database whenever a   *
  *   piece is moved.  It performs the following operations:  (1) update the    *
  *   note:  side = 1 if white is to move, 0 otherwise.  enemy is the opposite  *
  *   and is 1 if it is not white to move, 0 otherwise.                         *
  *                                                                             *
  *******************************************************************************
  */
-void MakeMove(TREE * RESTRICT tree, int ply, int move, int side) {
+void MakeMove(TREE * RESTRICT tree, int ply, int side, int move) {
   uint64_t bit_move;
-  int piece, from, to, captured, promote, enemy = Flip(side);
+  int piece, from, to, captured, promote, enemy = Flip(side), cpiece;
-  int cpiece;
 #if defined(DEBUG)
   int i;
 #endif
 /*
         PcOnSq(to) = pieces[side][promote];
         TotalPieces(side, occupied) += p_vals[promote];
         TotalPieces(side, promote)++;
         Material += PieceValues(side, promote);
         Set(to, Pieces(side, promote));
-        switch (promote) {
-          case knight:
-          case bishop:
-            TotalMinors(side)++;
-            break;
-          case rook:
-            TotalMajors(side)++;
-            break;
-          case queen:
-            TotalMajors(side) += 2;
-            break;
-        }
       } else if ((Abs(to - from) == 16) && (mask_eptest[to] & Pawns(enemy))) {
         EnPassant(ply + 1) = to + epsq[side];
         HashEP(to + epsq[side]);
+      }
       break;
       case pawn:
         HashP(enemy, to);
         break;
       case knight:
       case bishop:
-        TotalMinors(enemy)--;
+      case queen:
         break;
       case rook:
         if (Castle(ply + 1, enemy) > 0) {
           if ((to == rook_A[enemy]) && (Castle(ply + 1, enemy) & 2)) {
             Castle(ply + 1, enemy) &= 1;
           } else if ((to == rook_H[enemy]) && (Castle(ply + 1, enemy) & 1)) {
             Castle(ply + 1, enemy) &= 2;
             HashCastle(0, enemy);
+          }
+        }
-        TotalMajors(enemy)--;
-        break;
-      case queen:
-        TotalMajors(enemy) -= 2;
         break;
       case king:
 #if defined(DEBUG)
-        Print(128, "captured a king (Make)\n");
+        Print(2048, "captured a king (Make)\n");
         for (i = 1; i <= ply; i++)
+          Print(2048,
-          Print(128, "ply=%2d, piece=%2d,from=%2d,to=%2d,captured=%2d\n", i,
+              "ply=%2d, phase=%d, piece=%2d,from=%2d,to=%2d,captured=%2d\n",
-              Piece(tree->curmv[i]), From(tree->curmv[i]), To(tree->curmv[i]),
+              i, tree->phase[i], Piece(tree->curmv[i]), From(tree->curmv[i]),
-              Captured(tree->curmv[i]));
+              To(tree->curmv[i]), Captured(tree->curmv[i]));
-        Print(128, "ply=%2d, piece=%2d,from=%2d,to=%2d,captured=%2d\n", i,
+        Print(2048, "ply=%2d, piece=%2d,from=%2d,to=%2d,captured=%2d\n", i,
             piece, from, to, captured);
         if (log_file)
           DisplayChessBoard(log_file, tree->position);
 #endif
         break;
   ValidatePosition(tree, ply + 1, move, "MakeMove(2)");
 #endif
   return;
+}
-/* last modified 05/08/14 */
+/* last modified 01/06/16 */
 /*
  *******************************************************************************
  *                                                                             *
  *   MakeMoveRoot() is used to make a move at the root of the game tree,       *
  *   before any searching is done.  It uses MakeMove() to execute the move,    *
  *   rule by clearing the repetition list when a non-reversible move is made,  *
  *   since no repetitions are possible once such a move is played.             *
  *                                                                             *
  *******************************************************************************
  */
-void MakeMoveRoot(TREE * RESTRICT tree, int move, int side) {
+void MakeMoveRoot(TREE * RESTRICT tree, int side, int move) {
   int player;
 /*
  ************************************************************
  *                                                          *
  *  First, make the move and then reset the repetition      *
  *  index if the 50 move rule counter was reset to zero.    *
  *                                                          *
  ************************************************************
  */
-  MakeMove(tree, 0, move, side);
+  MakeMove(tree, 0, side, move);
   if (Reversible(1) == 0)
-    tree->rep_index = -1;
+    rep_index = -1;
-  tree->rep_list[++(tree->rep_index)] = HashKey;
+  tree->rep_list[++rep_index] = HashKey;
 /*
  ************************************************************
  *                                                          *
  *  One odd action is to note if the castle status is       *
  *  currently negative, which indicates that that side      *

Subversion Repositories Games.Chess Giants

Games.Chess Giants//engine-crafty/make.c – Rev 33 → 108