void AI::allPossibleMoves(boardState* nodeOrig, possibleMovesStruct* possibleMoves, int playerid){
	vector<fakePiece> piecesOnBoard;
	findPiecesOnBoard(nodeOrig, piecesOnBoard); // Creates a vector of all pieces on the board with their file rank type and owner
	
	if (piecesOnBoard.size() >= 1){
		for (int pos = 0; pos < piecesOnBoard.size(); pos++){
			bool myPiece = false;
			bool skip = false;
			fakePiece piecetoMove;

			//Check if creating a new possibleMovesStruct and checking it's size returns 0 
			while (!myPiece && !skip){
				if (pos < piecesOnBoard.size()){
					piecetoMove = piecesOnBoard[pos];
				}
				else{
					if (possibleMoves->availiableMoves.size() == 0){
						return;
					}
					else if (pos >= possibleMoves->availiableMoves.size()){
						skip = true;
						return;
					}
				}
				if (piecetoMove.owner() == playerid){
					myPiece = true;
				}
				else{
					skip = true;
				}
			}
			if (!skip){
				int typeofPiece = piecetoMove.type();
				std::pair<int, int>* position = new std::pair<int, int>;
				position->first = piecetoMove.file();
				position->second = piecetoMove.rank();

				switch (piecetoMove.type()) {
				case 'K':
					moveKing(possibleMoves, position, playerid, nodeOrig);
					break;
				case 'Q':
					moveQueen(possibleMoves, position, playerid, nodeOrig);
					break;
				case 'B':
					moveBishop(possibleMoves, position, playerid, nodeOrig);
					break;
				case 'N':
					moveKnight(possibleMoves, position, playerid, nodeOrig);
					break;
				case 'R':
					moveRook(possibleMoves, position, playerid, nodeOrig);
					break;
				case 'P':
					movePawn(possibleMoves, position, playerid, nodeOrig);
					break;
				default: 
					break;
				}
				delete position;
			}
		}

	}
	return;
}
Пример #2
0
int menacedPiecesSingleType(Board * actualBoard, int pieceColor, int pieceType){

	int piecesPosition[8], menacedValue;

	//Select the proper took color according to pieceColor
	BitMap piecesBitmap=0;

	if(pieceColor==BLACK)
	{
		piecesBitmap=actualBoard->blackPieces[pieceType];
	}
	else
	{
		piecesBitmap=actualBoard->whitePieces[pieceType];

	}


	int ppSuccess=getPiecePosition(&piecesBitmap,pieceType,piecesPosition);

	//Check if a table is empty return 0: cannot menace anyone!
	if(ppSuccess == NO_PIECES_IN_BOARD)
	{
		return 0;
	}
	if ( ppSuccess != SUCCESS ) {
		//logChess(WARN, "The piece position could not be retrieved.");
	}

	//for each position in the table let's calculate the menaced pieces
	int i;
	for(i=0; i<8; i++)
	{
		if((piecesPosition[i] == -9) ||( piecesPosition[i] ==- 1))
		{
			break;//exit from the for cycle if there are no extra movement to search
		}
		else
		{
			int col = piecesPosition[i] % 8;
			int row = (piecesPosition[i] / 8);

			BitMap aux_board = 0x8000000000000000;
			aux_board >>= piecesPosition[i];

			int generalCounter=0;

			Board tempBoard;
			memcpy(&tempBoard,actualBoard, sizeof(Board));

			switch (pieceType) {
			case King:
				moveKing(&aux_board, col, row, &generalCounter, &tempBoard);
				break;
			case Queens:
				moveQueen(&aux_board, col, row, &generalCounter, &tempBoard);
				break;
			case Rooks:
				moveRook(&aux_board, col, row, &generalCounter, &tempBoard);
				break;
			case Bishops:
				moveBishop(&aux_board, col, row, &generalCounter, &tempBoard);
				break;
			case Knights:
				moveKnight(&aux_board, col, row, &generalCounter, &tempBoard);
				break;
			case Pawns:
				movePawn(&aux_board, col, row, &generalCounter, &tempBoard);
				break;
			default:
				logChess(WARN, "Incorrect piece type.");
				break;
			}

			int j;
			for(j=0; j<MAX_NUM_MOVES; j++)
			{
				if((tempBoard.boardState[j].killedTypePiece > -1) && (tempBoard.boardState[j].killedTypePiece < 6))
				{
					menacedValue+=menacedHeuristicValue[tempBoard.boardState[j].killedTypePiece];
				}
				else
					break;
			}
		}
	}

	return menacedValue;

}
Пример #3
0
int findMoves(char pieceID,int currentPosition[2],char board[12][12],int moveList[1000][6])
{
    //Returns which piece is occupying a given square and all the possible moves for that piece

    switch(pieceID)
    {
    case 'o':
        break;
    case 'x':
        break;
    case 'P':
        printf("This is a white pawn, and these are it's possible moves: \n");
        movePawn(currentPosition,board,moveList);
        break;
    case 'p':
        printf("This is a black pawn and these are it's possible moves: \n");
        movePawn(currentPosition,board,moveList);
        break;
    case 'R':
        printf("This is a white rook and these are it's possible moves: \n");
        moveRook(currentPosition,board,moveList);
        break;
    case 'r':
        printf("This is a black rook and these are it's possible moves: \n");
        moveRook(currentPosition,board,moveList);
        break;
    case 'N':
        printf("This is a white knight and these are it's possible moves: \n");
        moveKnight(currentPosition,board);
        break;
    case 'n':
        printf("This is a black knight and these are it's possible moves: \n");
        moveKnight(currentPosition,board);
        break;
    case 'B':
        printf("This is a white bishop and these are it's possible moves: \n");
        moveBishop(currentPosition,board,moveList);
        break;
    case 'b':
        printf("This is a black bishop and these are it's possible moves: \n");
        moveBishop(currentPosition,board,moveList);
        break;
    case 'Q':
        printf("This is a white queen and these are it's possible moves: \n");
        moveQueen(currentPosition,board);
        break;
    case 'q':
        printf("This is a black queen and these are it's possible moves: \n");
        moveQueen(currentPosition,board);
        break;
    case 'A':
        printf("This is a white king and these are it's possible moves: \n");
        moveKing(currentPosition,board);
        break;
    case 'a':
        printf("This is a black king and these are it's possible moves: \n");
        moveKing(currentPosition,board);
        break;
    }
    return pieceID;
}