/* A very silly random search 'algorithm' */
void randomSearch() {
int queen, iter = 0;
int optimum = (nqueens-1)*nqueens/2;
while (evaluateBuffer() != optimum) {
printf("iteration %d: evaluation=%d\n", iter++, evaluateBuffer());
if (iter == MAXITER) break; /* give up */
/* generate a (new) random state: for each queen do ...*/
for (queen=0; queen < nqueens; queen++) {
int pos, newpos;
/* position (=column) of queen */
pos = columnOfQueen(queen);
/* change in random new location */
newpos = pos;
while (newpos == pos) {
newpos = random() % nqueens;
}
moveQueen(queen, newpos);
}
}
if (iter < MAXITER) {
printf ("Solved puzzle. ");
}
printf ("Final state is");
printState();
}
void hillClimbing() {
int iterations = 0;
int optimum = (nqueens-1)*nqueens/2;
int current_state[nqueens], i;
for (i=0; i<nqueens; i++) {
current_state[i] = queens_buffer[i];
}
while ((iterations < MAXITER) && (evaluateBuffer() != optimum)) {
int best_move_evaluation = evaluateBuffer(); // Value to be maximized. Initialize with the current evaluation.
nsuccessors = 0;
// Loops through all possible moves
int i, j;
for (i=0; i<nqueens; i++) {
for (j=0; j<nqueens; j++) {
moveQueen(i,j);
int successor_evaluation = evaluateBuffer();
if (successor_evaluation > best_move_evaluation) {
saveToSuccessors(0);
nsuccessors = 1;
best_move_evaluation = successor_evaluation;
}
else if (successor_evaluation == best_move_evaluation) {
saveToSuccessors(nsuccessors);
nsuccessors++;
}
// Undo last move
setBuffer(current_state);
}
}
// Select randomly the best successor
if (nsuccessors != 0) {
int random_successor = rand() % nsuccessors;
setBuffer(successors[random_successor]);
}
// Update current state
for (i=0; i<nqueens; i++) {
current_state[i] = queens_buffer[i];
}
iterations++;
}
if (evaluateBuffer() == optimum) {
printf ("Solved puzzle.\n");
printf ("Solution:");
printState();
solutions_found++;
}
else {
printf("Puzzle not solved (maximum number of iterations). Final state:\n");
printState();
}
}
void simulatedAnnealing() {
clock_t clock_start;
int optimum = (nqueens-1)*nqueens/2;
int iterations = 0;
double current_temperature = INITIAL_TEMPERATURE;
// Starts the clock counter
clock_start = clock();
while (evaluateBuffer() != optimum && current_temperature > 0.005) {
// Save current state
int current_evaluation = evaluateBuffer();
int current_state[nqueens], i;
for (i=0; i<nqueens; i++) {
current_state[i] = queens_buffer[i];
}
setBuffer(current_state);
// Make a random move
int random_queen = rand() % nqueens;
int random_column = rand() % nqueens;
moveQueen(random_queen, random_column);
int successor_evaluation = evaluateBuffer();
int delta = successor_evaluation - current_evaluation;
// If the chosen successor is better than the current state
if (delta > 0) {
// do nothing
}
else {
double probability_of_change = exp(delta/current_temperature);
double random_number = (rand() % 100) / (double)100;
if (random_number < probability_of_change) {
// do nothing
}
else { // Else, revert state to the original one
setBuffer(current_state);
}
}
// Update temperature
current_temperature = timeToTemperature(clock_start);
iterations++;
}
if (evaluateBuffer() == optimum) {
printf ("Solved puzzle.\n");
printf ("Solution:");
printState();
solutions_found++;
}
else {
printf("Not solved in this iteration. Final state:");
printState();
}
}
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;
}
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;
}
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;
}
