TalkChess.com

Code: Select all

static inline int NegaMaxSearch(int alpha, int beta, CHESSBOARD *board, SEARCH *info, int depth)
{
	int legalMoves = 0;
	int bestScore = -50000;
	int bestMove = 0;
	int bestLast = 0;
	
	if(info->bestMove)
		bestLast = info->bestMove;
	
	if(InCheck(board, side))
		depth++;

	if(!depth)
	{
		info->nodes++;
		return QuiescenceSearch(alpha, beta, board, info, 4);
	}
	
	MOVELIST list[1];
	GenerateMoves(board, list);
	
	for(int moveNum = 0; moveNum < list->moveCount; ++moveNum)
	{
		CHESSBOARD boardStored[1];
		boardStored[0] = board[0];
		
		if(!MakeMove(board, list->moves[moveNum].move, all))
			continue;
		
		legalMoves++;
		int score = -NegaMaxSearch(-beta, -alpha, board, info, depth - 1);
		
		if(score > bestScore)
		{
			bestScore = score;
			bestMove = list->moves[moveNum].move;
			
			info->bestScore = bestScore;
			info->bestMove = bestMove;
			
			if(score >= beta)
				return beta;
				
			if(score > alpha)
				alpha = score;
		}
		
		TakeBack(board, boardStored);	
	}
	
	// checkmate/stalemate detection
	if(!legalMoves)
	{
		if(InCheck(board, side))
			return -100000; // on checkmate
			
		else
			return 0; // on stalemate
	}
	
	if(bestMove)
	{
		info->bestScore = bestScore;
		info->bestMove = bestMove;
	}
	
	return alpha;
}


static inline void SearchPosition(CHESSBOARD *board, SEARCH *info, int depth)
{
	for(int currentDepth = 1; currentDepth <= depth; currentDepth++)
	{
		NegaMaxSearch(-50000, 50000, board, info, currentDepth);
		printf("info score cp %d depth %d nodes %ld\n", info->bestScore, currentDepth, info->nodes);
	}
	
	if(info->bestMove)
	{
		printf("bestmove ");
		PrintMove(info->bestMove);
		printf("\n");
	}
}

Code: Select all

Move pvStack[10000];
Move *pvPtr = pvStack;

int Search()
{
  Move *pvStart = pvPtr; // start of own PV
  *pvStart = 0; // initialize empty PV at the top of the PV stack
  
  
  // where you increase alpha because of a better move:
  pvPtr = pvStart + 1;
  while((*pvStart++ = *pvPtr++)) ; // copy PV of daughter, including the terminating 0
  *pvStart = move; // the move we just searched is now the first of the new PV
  
  // when returning
  pvPtr = pvStart; // pop PV (but leave data in place, so daughter can pick it up)
}

Code: Select all

for(int i =0; i < 10000; ++i)
{
	if(pvStack[i])
	{
		PrintMove(pvStack[i]);
	}
}

Code: Select all

int pvStack[10000];
int *pvPtr = pvStack;

static int NegaMaxSearch(int alpha, int beta, CHESSBOARD *board, SEARCH *info, int depth)
{
	...
	
	for(int moveNum = 0; moveNum < list->moveCount; ++moveNum)
	{
		...
		
		if(score >= beta)
		{
			...

			return beta; // fail hard beta-cutoff
		}
			
		if(score > alpha)
		{
			alpha = score;			
			...
				
			pvPtr = pvStart + 1;
			
			while((*pvStart++ = *pvPtr++)) ; // copy PV of daughter, including the terminating 0
				*pvStart = list->moves[moveNum].move; // the move we just searched is now the first of the new PV
		}
	}
		
	...
	
	pvPtr = pvStart; // pop PV (but leave data in place, so daughter can pick it up)
	
	return alpha;
}

Code: Select all

for(int i =0; i < 10000; ++i)
{
	if(pvStack[i])
	{
		PrintMove(pvStack[i]);
	}
}