int play_game( individual* p1, individual* p2 ) {
board* b;
play* next_play;
play_list* pl;
int x, player, result;
cgp_net* net;
b = create_board();
player = MAX;
while( game_status( b ) == NOT_DONE ) {
pl = create_possible_plays( b, player );
/* choose play */
if( player == MAX ) {
net = p1->net;
} else {
net = p2->net;
}
/* this is combining too much into one function */
next_play = select_play( pl, player, net );
/* switch active player */
if( player == MAX ) {
player = MIN;
} else {
player = MAX;
}
}
result = game_status( b );
delete_board( b );
/* record wins / loss / draw */
return( result );
}
void test_for_memory_leaks() {
int x;
board *board;
play *play;
play_list *pl;
/*
printf( "Hit enter to test board creation and deletion\n" );
getchar();
*/
printf( "Testing board creation and deletion\n" );
for( x = 0; x < 100000; x++ ) {
board = create_board( );
// printf( "%d\n", board );
delete_board( board );
}
// printf( "%d\n", board );
/*
printf( "Hit enter to test play creation and deletion\n" );
getchar();
*/
printf( "Testing play creation and deletion\n" );
for( x = 0; x < 100000; x++ ) {
play = create_play( );
printf( "%d\n", play );
delete_play( play );
}
printf( "%d\n", play );
/*
printf( "Hit enter to test play list creation and deletion\n" );
getchar();
*/
printf( "Testing play list creation and deletion\n" );
for( x = 0; x < 1000000; x++ ) {
pl = create_play_list( 5 );
/* print_play_list( pl ); */
printf( "%d\n", pl );
delete_play_list( pl );
}
printf( "%d\n", pl );
}
int main(){
board *b;
play_list *pl;
b = create_board();
printf( "Blank Board\n" );
print_board( b );
b->state[0][0] = X;
b->state[1][0] = X;
b->state[2][0] = O;
printf( "Populated Board\n" );
print_board( b );
pl = create_possible_plays( b, O );
print_play_list( pl );
printf( "Original Board\n" );
print_board( b );
delete_possible_plays( pl );
delete_board( b );
}
void create_print_status_evaluate(){
int a, b, c, d, e, f, g, h, i;
board *board;
board = create_board( );
for( a = -1; a < 2; a++ ){
for( b = -1; b < 2; b++ ){
for( c = -1; c < 2; c++ ){
for( d = -1; d < 2; d++ ){
for( e = -1; e < 2; e++ ){
for( f = -1; f < 2; f++ ){
for( g = -1; g < 2; g++ ){
for( h = -1; h < 2; h++ ){
for( i = -1; i < 2; i++ ){
board->state[0][0] = a;
board->state[0][1] = b;
board->state[0][2] = c;
board->state[1][0] = d;
board->state[1][1] = e;
board->state[1][2] = f;
board->state[2][0] = g;
board->state[2][1] = h;
board->state[2][2] = i;
print_board( board );
printf( "\n" );
}
}
}
}
}
}
}
}
}
delete_board( board );
}
int bad_possible_elimination(sudoku_board board, int side){
int i, j, k, n, m,aa=0, abc, alone_ok=0;
sudoku_board test_board;
// print_board(board, side);
for (i=0; i<side; ++i) {//ROW
for (j=0; j<side; ++j) {//COLUMN
//printf("row=%d column=%d\n", i, j);
//printf("\tvalue = %d\n", get_value(&board[i][j]));
if (get_value(&board[i][j])==0) {
for (k=0; k<side; ++k) {//POSSIBLE
//printf("k=%d possible=%d\n", k, board[i][j].possible[k]);
if (board[i][j].possible[k]){
test_board = create_board(side);
for (n=0; n<side; ++n)
for (m=0; m<side; ++m){
if (get_value(&board[n][m]))
found_value(test_board, side, n, m, get_value(&board[n][m]));
}
found_value(test_board, side, i, j, board[i][j].possible[k]);
alone_ok=0;
for (n=0; n<side; ++n) {
if ((board[i][n].possibles)==1) {
for (m=0; m<side; ++m) {
if (board[i][n].possible[m]) {
alone_ok = 1;
found_value(test_board, side, i, n, board[i][n].possible[m]);
}
}
}
if ((board[n][j].possibles)==1) {
for (m=0; m<side; ++m) {
if (board[n][j].possible[m]) {
alone_ok = 1;
found_value(test_board, side, n, j, board[n][j].possible[m]);
}
}
}
}
if (singleton(test_board, side, i, j, i+1, j+1))
alone_ok = 1;
if (pairs(test_board, side, i, j, i+1, j+1))
alone_ok = 1;
if (alone_ok) {
while (1){
if (alone(board, side))
continue;
if (singleton(board, side, 0, 0, side, side))
continue;
if (pairs(board, side, 0, 0, side, side))
continue;
break;
}
}
abc = check_solution(test_board, side);
//printf("%d\n", aa);
switch (abc) {
case 0:
found_value(board, side, i, j, board[i][j].possible[k]);
delete_board(test_board, side);
return -1;
case 1:
delete_possible(&board[i][j], board[i][j].possible[k], side);
++aa;
break;
default:
break;
}
delete_board(test_board, side);
}
}
}
}
}
return aa;
}
void delete_play( play* p ) {
delete_board( p->board );
free( p );
}
