Tictactoe with Al

[pacman169]

Is strange. I never got it working. I`m not in my Linux partition just now to compile, but the code compiles and output is strange eg. computer does not play at all.

#include <iostream>
#include <bitset>
#include <cstdlib>
#include <algorithm>
#define NOUGHTS 1
#define CROSSES -1



using std::cin;
using std::cout;
using std::ostream;
using std::endl;
using std::bitset;


const size_t N = 3;
typedef bitset <N*N> board;


const board wins[] = {
    board(0b111000000), board(0b000111000), board(0b000000111),    // rows
    board(0b100100100), board(0b010010010), board(0b001001001),	// cols
    board(0b100010001), board(0b001010100)	// diagonals
};

board noughts;			// bit board for first player
board crosses;			// bit board for second player


const char NOUGHT = 'O';
const char CROSS = 'X';

int Search (int depth, board b);
int ComputerThink (board b, unsigned int depth);
board combined();
ostream & print_board(ostream & stm = cout, board b = combined());

// This indicates the current player. Computer plays noughts.
bool curr_move_noughts = true;

board
combined()
{
    return noughts | crosses;
}				// combined bit board for both players

bool
valid(size_t row, size_t col)
{
    return row < N && col < N;
}

size_t
pos(size_t row, size_t col)
{
    return row * N + col;
}				// map row, col to bit position

bool
occupied(size_t row, size_t col)
{
    return valid(row, col) && combined()[pos(row, col)];
}

bool
free(size_t row, size_t col)
{
    return valid(row, col) && !occupied(row, col);
}

size_t last_move_row = -1, last_move_col = -1 ;

void make_move( size_t row, size_t col, board & b )
{
    if (free(row, col))
    {
	b[pos(row, col)] = true;
        last_move_row = row ;
        last_move_col = col ;
    } 
}

void unMake(board & b )
{
	
    
    if (valid(last_move_row, last_move_col))       // if valid last_move_row, last_move_col
    {
    int row= -1;
    int col= -1;
    b[pos(row, col)] = true;
    last_move_row = -1 ;
    last_move_col = -1 ; 
    }
}

void
make_move(size_t row, size_t col)                                   
{
    if (curr_move_noughts)
	make_move(row, col, noughts);
    else
	make_move(row, col, crosses);
}

bool
is_win(board b)
{
    for (int i = 0; i < sizeof(wins) / sizeof(wins[0]); ++i) {
	if ((wins[i] & b) == wins[i])
	    return true;
    }
    return false;
}

bool
is_win()
{
    return is_win(curr_move_noughts ? noughts : crosses);
}

// is the board full?
bool is_full(board b)
{
    static board fullboard(0b111111111);
    return b == fullboard;
}

bool is_full()
{
    return is_full(curr_move_noughts ? noughts : crosses);
    
}


static int eval(board b)
{
    

    if (is_win (NOUGHTS))
    {
        return 1;
    }
    else if (is_win (CROSSES))
    {
        return -1;
    }
    else
    {
        return 0;
    }
}

  


void
play()
{

    int row = -1;		// For player input
    int col = -1;

    for (int turns = 0; turns < 9; ++turns) {
	curr_move_noughts = !curr_move_noughts;

	if (curr_move_noughts) {
	  board b = combined();	
	  int z;
	  z = ComputerThink(b,1);
	} 
	 
         else {
	    cout << "Choose a move..." << endl;
	    cout << "Enter row and col : ";
	    cin >> row >> col;
	    // dmh - note that valid rows/col are 0-2, not 1-3. If you
	    // want the user to enter 1-3 then decrement the value
	    // they enter right after they enter it
	    if (!valid(row,col)) {
		cout << "Illegal move!  Try again...\n" << endl;
	    } else {
		make_move(row, col);
	    }
	}
	print_board();
	if (is_win()) {
	    cout << "Player " << (curr_move_noughts ? NOUGHT : CROSS) << " has won!" << endl; exit(0);
	} else if (is_full()) {
	    cout << "Game ended in a tie!" << endl;
	}
    }
}



ostream & print_board(ostream & stm, board b)
{
    stm << "------\n";
    for (std::size_t i = 0; i < N; ++i) {
	for (std::size_t j = 0; j < N; ++j) {
	    const size_t
		k = pos(i, j);
	    if (b[k])
		stm << (noughts[k] ? NOUGHT : CROSS) << ' ';
	    else
		stm << ". ";
	}
	stm << '\n';
    }
    return stm << "------\n";
}





int negamax( board b, unsigned int depth, unsigned int side)

{


if (depth==0)

{

  int score=eval(b);
  return side * score;

}

int bestScore = -1000;      
for (int x = 0; x < 9; ++x) {
 for (int y = 0; y < 9; ++y) {
while (!occupied(x,y));
make_move(x,y);              
int val = -negamax(b, depth -1, -side);
unMake(b);
bestScore = std::max(bestScore, val);

 
   }
}


return bestScore;

}


int ComputerThink (board b, unsigned int depth)

{
	
int g;

                                        // side = b->turn ? 1 : -1; ??

// Search now

for (int x = 0; x < 9; ++x) {
for (int y = 0; y < 9; ++y) {
while (!occupied(x,y));
{

g= negamax (b,1,1);
make_move(x, y);

                
      }
   
  }
 }

  return g;

}


int
main()
{
    play();
    return 0;
}