v1.1.2

Bugfixes

Author: bctboi23

makemove.c

@@ -27,22 +27,22 @@ static void ClearPiece(const int sq, S_BOARD *pos) {
 
 	ASSERT(SqOnBoard(sq));
 	ASSERT(CheckBoard(pos));
-	
+
     int pce = pos->pieces[sq];
-	
+
     ASSERT(PieceValid(pce));
-	
+
 	int col = PieceCol[pce];
 	int index = 0;
 	int t_pceNum = -1;
-	
+
 	ASSERT(SideValid(col));
-	
+
     HASH_PCE(pce,sq);
-	
+
 	pos->pieces[sq] = EMPTY;
     pos->material[col] -= PieceVal[pce];
-	
+
 	if(PieceBig[pce]) {
 			pos->bigPce[col]--;
 		if(PieceMaj[pce]) {
@@ -54,34 +54,34 @@ static void ClearPiece(const int sq, S_BOARD *pos) {
 		CLRBIT(pos->pawns[col],SQ64(sq));
 		CLRBIT(pos->pawns[BOTH],SQ64(sq));
 	}
-	
+
 	for(index = 0; index < pos->pceNum[pce]; ++index) {
 		if(pos->pList[pce][index] == sq) {
 			t_pceNum = index;
 			break;
 		}
 	}
-	
+
 	ASSERT(t_pceNum != -1);
 	ASSERT(t_pceNum>=0&&t_pceNum<10);
-	
-	pos->pceNum[pce]--;		
-	
+
+	pos->pceNum[pce]--;
+
 	pos->pList[pce][t_pceNum] = pos->pList[pce][pos->pceNum[pce]];
-  
+
 }
 
 
 static void AddPiece(const int sq, S_BOARD *pos, const int pce) {
 
     ASSERT(PieceValid(pce));
     ASSERT(SqOnBoard(sq));
-	
+
 	int col = PieceCol[pce];
 	ASSERT(SideValid(col));
 
     HASH_PCE(pce,sq);
-	
+
 	pos->pieces[sq] = pce;
 
     if(PieceBig[pce]) {
@@ -95,40 +95,40 @@ static void AddPiece(const int sq, S_BOARD *pos, const int pce) {
 		SETBIT(pos->pawns[col],SQ64(sq));
 		SETBIT(pos->pawns[BOTH],SQ64(sq));
 	}
-	
+
 	pos->material[col] += PieceVal[pce];
 	pos->pList[pce][pos->pceNum[pce]++] = sq;
-	
+
 }
 
 static void MovePiece(const int from, const int to, S_BOARD *pos) {
 
     ASSERT(SqOnBoard(from));
     ASSERT(SqOnBoard(to));
-	
+
 	int index = 0;
-	int pce = pos->pieces[from];	
+	int pce = pos->pieces[from];
 	int col = PieceCol[pce];
 	ASSERT(SideValid(col));
     ASSERT(PieceValid(pce));
-	
+
 #ifdef DEBUG
 	int t_PieceNum = FALSE;
 #endif
 
 	HASH_PCE(pce,from);
 	pos->pieces[from] = EMPTY;
-	
+
 	HASH_PCE(pce,to);
 	pos->pieces[to] = pce;
-	
+
 	if(!PieceBig[pce]) {
 		CLRBIT(pos->pawns[col],SQ64(from));
 		CLRBIT(pos->pawns[BOTH],SQ64(from));
 		SETBIT(pos->pawns[col],SQ64(to));
-		SETBIT(pos->pawns[BOTH],SQ64(to));		
-	}    
-	
+		SETBIT(pos->pawns[BOTH],SQ64(to));
+	}
+
 	for(index = 0; index < pos->pceNum[pce]; ++index) {
 		if(pos->pList[pce][index] == from) {
 			pos->pList[pce][index] = to;
@@ -144,20 +144,20 @@ static void MovePiece(const int from, const int to, S_BOARD *pos) {
 int MakeMove(S_BOARD *pos, int move) {
 
 	ASSERT(CheckBoard(pos));
-	
+
 	int from = FROMSQ(move);
     int to = TOSQ(move);
     int side = pos->side;
-	
+
 	ASSERT(SqOnBoard(from));
     ASSERT(SqOnBoard(to));
     ASSERT(SideValid(side));
     ASSERT(PieceValid(pos->pieces[from]));
 	ASSERT(pos->hisPly >= 0 && pos->hisPly < MAXGAMEMOVES);
 	ASSERT(pos->ply >= 0 && pos->ply < MAXDEPTH);
-	
+
 	pos->history[pos->hisPly].posKey = pos->posKey;
-	
+
 	if(move & MFLAGEP) {
         if(side == WHITE) {
             ClearPiece(to-10,pos);
@@ -180,11 +180,11 @@ int MakeMove(S_BOARD *pos, int move) {
 			break;
             default: ASSERT(FALSE); break;
         }
-    }	
-	
+    }
+
 	if(pos->enPas != NO_SQ) HASH_EP;
     HASH_CA;
-	
+
 	pos->history[pos->hisPly].move = move;
     pos->history[pos->hisPly].fiftyMove = pos->fiftyMove;
     pos->history[pos->hisPly].enPas = pos->enPas;
@@ -195,22 +195,22 @@ int MakeMove(S_BOARD *pos, int move) {
     pos->enPas = NO_SQ;
 
 	HASH_CA;
-	
+
 	int captured = CAPTURED(move);
     pos->fiftyMove++;
-	
+
 	if(captured != EMPTY) {
         ASSERT(PieceValid(captured));
         ClearPiece(to, pos);
         pos->fiftyMove = 0;
     }
-	
+
 	pos->hisPly++;
 	pos->ply++;
-	
+
 	ASSERT(pos->hisPly >= 0 && pos->hisPly < MAXGAMEMOVES);
 	ASSERT(pos->ply >= 0 && pos->ply < MAXDEPTH);
-	
+
 	if(PiecePawn[pos->pieces[from]]) {
         pos->fiftyMove = 0;
         if(move & MFLAGPS) {
@@ -224,52 +224,52 @@ int MakeMove(S_BOARD *pos, int move) {
             HASH_EP;
         }
     }
-	
+
 	MovePiece(from, to, pos);
-	
+
 	int prPce = PROMOTED(move);
     if(prPce != EMPTY)   {
         ASSERT(PieceValid(prPce) && !PiecePawn[prPce]);
         ClearPiece(to, pos);
         AddPiece(to, pos, prPce);
     }
-	
+
 	if(PieceKing[pos->pieces[to]]) {
         pos->KingSq[pos->side] = to;
     }
-	
+
 	pos->side ^= 1;
     HASH_SIDE;
 
     ASSERT(CheckBoard(pos));
-	
-		
+
+
 	if(SqAttacked(pos->KingSq[side],pos->side,pos))  {
         TakeMove(pos);
         return FALSE;
     }
-	
+
 	return TRUE;
-	
+
 }
 
 void TakeMove(S_BOARD *pos) {
-	
+
 	ASSERT(CheckBoard(pos));
-	
+
 	pos->hisPly--;
     pos->ply--;
-	
+
 	ASSERT(pos->hisPly >= 0 && pos->hisPly < MAXGAMEMOVES);
 	ASSERT(pos->ply >= 0 && pos->ply < MAXDEPTH);
-	
+
     int move = pos->history[pos->hisPly].move;
     int from = FROMSQ(move);
-    int to = TOSQ(move);	
-	
+    int to = TOSQ(move);
+
 	ASSERT(SqOnBoard(from));
     ASSERT(SqOnBoard(to));
-	
+
 	if(pos->enPas != NO_SQ) HASH_EP;
     HASH_CA;
 
@@ -282,7 +282,7 @@ void TakeMove(S_BOARD *pos) {
 
     pos->side ^= 1;
     HASH_SIDE;
-	
+
 	if(MFLAGEP & move) {
         if(pos->side == WHITE) {
             AddPiece(to-10, pos, bP);
@@ -298,25 +298,25 @@ void TakeMove(S_BOARD *pos) {
             default: ASSERT(FALSE); break;
         }
     }
-	
+
 	MovePiece(to, from, pos);
-	
+
 	if(PieceKing[pos->pieces[from]]) {
         pos->KingSq[pos->side] = from;
     }
-	
+
 	int captured = CAPTURED(move);
     if(captured != EMPTY) {
         ASSERT(PieceValid(captured));
         AddPiece(to, pos, captured);
     }
-	
+
 	if(PROMOTED(move) != EMPTY)   {
         ASSERT(PieceValid(PROMOTED(move)) && !PiecePawn[PROMOTED(move)]);
         ClearPiece(from, pos);
         AddPiece(from, pos, (PieceCol[PROMOTED(move)] == WHITE ? wP : bP));
     }
-	
+
     ASSERT(CheckBoard(pos));
 
 }
@@ -341,7 +341,7 @@ void MakeNullMove(S_BOARD *pos) {
     pos->side ^= 1;
     pos->hisPly++;
     HASH_SIDE;
-   
+
     ASSERT(CheckBoard(pos));
 	ASSERT(pos->hisPly >= 0 && pos->hisPly < MAXGAMEMOVES);
 	ASSERT(pos->ply >= 0 && pos->ply < MAXDEPTH);
@@ -364,21 +364,8 @@ void TakeNullMove(S_BOARD *pos) {
     if(pos->enPas != NO_SQ) HASH_EP;
     pos->side ^= 1;
     HASH_SIDE;
-  
+
     ASSERT(CheckBoard(pos));
 	ASSERT(pos->hisPly >= 0 && pos->hisPly < MAXGAMEMOVES);
 	ASSERT(pos->ply >= 0 && pos->ply < MAXDEPTH);
 }
-
-
-
-
-
-
-
-
-
-
-
-
-

search.c

@@ -10,7 +10,7 @@ static const int minDepth = 3;
 
 // Razoring Values
 static const int RazorDepth = 2;
-static const int RazorMargin = 400;
+static const int RazorMargin[3] = {0, 350, 500};
 
 // LMR Values
 static const int LateMoveDepth = 3;
@@ -106,17 +106,17 @@ static int Quiescence(int alpha, int beta, S_BOARD *pos, S_SEARCHINFO *info) {
 		return 0;
 	}
 
+	if(pos->ply > MAXDEPTH - 1) {
+		return EvalPosition(pos);
+	}
+
 	// Mate Distance Pruning
 	alpha = MAX(alpha, -INFINITE + pos->ply);
 	beta = MIN(beta, INFINITE - pos->ply);
 	if (alpha >= beta) {
 		return alpha;
 	}
 
-	if(pos->ply > MAXDEPTH - 1) {
-		return EvalPosition(pos);
-	}
-
 	int Score = EvalPosition(pos);
 
 	ASSERT(Score>-INFINITE && Score<INFINITE);
@@ -224,21 +224,21 @@ static int AlphaBeta(int alpha, int beta, int depth, S_BOARD *pos, S_SEARCHINFO
 			return 0;
 		}
 
-		// Razoring (not done if in null move)
-		if (depth <= RazorDepth && !PvMove && !InCheck && pos->history[pos->hisPly].move) {
-			if (EvalPosition(pos) + RazorMargin < alpha) {
-				// drop into qSearch if move most likely won't beat alpha
-				info->nodesPruned++;
-				return Quiescence(alpha, beta, pos, info);
-			}
-		}
-
 		if (Score >= beta && abs(Score) < ISMATE) {
 			info->nullCut++;
 			return beta;
 		}
 	}
 
+	// Razoring (not done if in null move)
+	if (depth <= RazorDepth && !PvMove && !InCheck && pos->history[pos->hisPly].move) {
+		if (EvalPosition(pos) + RazorMargin[depth] <= alpha) {
+			// drop into qSearch if move most likely won't beat alpha
+			info->nodesPruned++;
+			return Quiescence(alpha, beta, pos, info);
+		}
+	}
+
 	S_MOVELIST list[1];
     GenerateAllMoves(pos,list);