int main(int argc, char** argv){
start_game();
char continue_play;
float player_loss_percent, player_win_percent, tie_percent;
for(int count=0; count<MAX_GAMES; count++){
play_game();
who_wins();
if (count==MAX_GAMES-1){
printf("\nDo you wish to continue playing? y/n: ");
scanf("%*[ \n\t]%c", &continue_play);// http://stackoverflow.com/questions/13542055/in-c-how-to-do-scanf-for-single-char
if (tolower(continue_play)=='y'){
count = -1;
}
}
}
int total_count = player_loss_count+player_win_count +tie_count;
player_loss_percent = 100*((float)player_loss_count/total_count);
player_win_percent = 100*((float)player_win_count/total_count);
tie_percent = 100-(player_win_percent+player_loss_percent);
printf(" You won %d (%.1f%%) of %d games, lost %d (%.1f%c) and tied %d (%.1f%c)... ", player_win_count, player_win_percent, total_count, player_loss_count, player_loss_percent, '%', tie_count, tie_percent, '%');
if(player_win_percent>50)
printf("Well done, congratulations!\n");
else if (player_win_percent<50)
printf("Boohoo!\n");
else
printf("Ah, you just got lucky\n");
}
/* --------------------------------------------------------------*/
void
play_gmp(Gameinfo *gameinfo, int simplified)
{
SGFTree sgftree;
Gmp *ge;
GmpResult message;
const char *error;
int i, j;
int passes = 0; /* two passes and its over */
int to_move; /* who's turn is next ? */
int mycolor = -1; /* who has which color */
int yourcolor;
if (gameinfo->computer_player == WHITE)
mycolor = 1;
else if (gameinfo->computer_player == BLACK)
mycolor = 0;
sgftree_clear(&sgftree);
sgftreeCreateHeaderNode(&sgftree, board_size, komi, gameinfo->handicap);
ge = gmp_create(0, 1);
TRACE("board size=%d\n", board_size);
/*
* The specification of the go modem protocol doesn't even discuss
* komi. So we have to guess the komi. If the komi is set on the
* command line, keep it. Otherwise, its value will be 0.0 and we
* use 5.5 in an even game, 0.5 otherwise.
*/
if (komi == 0.0) {
if (gameinfo->handicap == 0)
komi = 5.5;
else
komi = 0.5;
}
if (!simplified) {
/* Leave all the -1's so the client can negotiate the game parameters. */
if (chinese_rules)
gmp_startGame(ge, -1, -1, 5.5, -1, mycolor, 0);
else
gmp_startGame(ge, -1, -1, 5.5, 0, mycolor, 0);
}
else {
gmp_startGame(ge, board_size, gameinfo->handicap,
komi, chinese_rules, mycolor, 1);
}
do {
message = gmp_check(ge, 1, NULL, NULL, &error);
} while (message == gmp_nothing || message == gmp_reset);
if (message == gmp_err) {
fprintf(stderr, "gnugo-gmp: Error \"%s\" occurred.\n", error);
exit(EXIT_FAILURE);
}
else if (message != gmp_newGame) {
fprintf(stderr, "gnugo-gmp: Expecting a newGame, got %s\n",
gmp_resultString(message));
exit(EXIT_FAILURE);
}
gameinfo->handicap = gmp_handicap(ge);
if (!check_boardsize(gmp_size(ge), stderr))
exit(EXIT_FAILURE);
gnugo_clear_board(gmp_size(ge));
/* Let's pretend GMP knows about komi in case something will ever change. */
komi = gmp_komi(ge);
#if ORACLE
if (metamachine && oracle_exists)
oracle_clear_board(board_size);
#endif
sgfOverwritePropertyInt(sgftree.root, "SZ", board_size);
TRACE("size=%d, handicap=%d, komi=%f\n", board_size,
gameinfo->handicap, komi);
if (gameinfo->handicap)
to_move = WHITE;
else
to_move = BLACK;
if (gmp_iAmWhite(ge)) {
mycolor = WHITE; /* computer white */
yourcolor = BLACK; /* human black */
}
else {
mycolor = BLACK;
yourcolor = WHITE;
}
gameinfo->computer_player = mycolor;
sgf_write_header(sgftree.root, 1, get_random_seed(), komi,
gameinfo->handicap, get_level(), chinese_rules);
gameinfo->handicap = gnugo_sethand(gameinfo->handicap, sgftree.root);
sgfOverwritePropertyInt(sgftree.root, "HA", gameinfo->handicap);
/* main GMP loop */
while (passes < 2) {
if (to_move == yourcolor) {
int move;
/* Get opponent's move from gmp client. */
message = gmp_check(ge, 1, &j, &i, &error);
if (message == gmp_err) {
fprintf(stderr, "GNU Go: Sorry, error from gmp client\n");
sgftreeAddComment(&sgftree, "got error from gmp client");
sgffile_output(&sgftree);
return;
}
if (message == gmp_undo) {
int k;
assert(j > 0);
for (k = 0; k < j; k++) {
if (!undo_move(1)) {
fprintf(stderr, "GNU Go: play_gmp UNDO: can't undo %d moves\n",
j - k);
break;
}
sgftreeAddComment(&sgftree, "undone");
sgftreeBack(&sgftree);
to_move = OTHER_COLOR(to_move);
}
continue;
}
if (message == gmp_pass) {
passes++;
move = PASS_MOVE;
}
else {
passes = 0;
move = POS(i, j);
}
TRACE("\nyour move: %1m\n\n", move);
sgftreeAddPlay(&sgftree, to_move, I(move), J(move));
gnugo_play_move(move, yourcolor);
sgffile_output(&sgftree);
}
else {
/* Generate my next move. */
float move_value;
int move;
if (autolevel_on)
adjust_level_offset(mycolor);
move = genmove(mycolor, &move_value, NULL);
gnugo_play_move(move, mycolor);
sgffile_add_debuginfo(sgftree.lastnode, move_value);
if (is_pass(move)) {
/* pass */
sgftreeAddPlay(&sgftree, to_move, -1, -1);
gmp_sendPass(ge);
++passes;
}
else {
/* not pass */
sgftreeAddPlay(&sgftree, to_move, I(move), J(move));
gmp_sendMove(ge, J(move), I(move));
passes = 0;
TRACE("\nmy move: %1m\n\n", move);
}
sgffile_add_debuginfo(sgftree.lastnode, 0.0);
sgffile_output(&sgftree);
}
to_move = OTHER_COLOR(to_move);
}
/* two passes: game over */
gmp_sendPass(ge);
if (!quiet)
fprintf(stderr, "Game over - waiting for client to shut us down\n");
who_wins(mycolor, stderr);
if (showtime) {
gprintf("\nSLOWEST MOVE: %d at %1m ", slowest_movenum, slowest_move);
fprintf(stderr, "(%.2f seconds)\n", slowest_time);
fprintf(stderr, "\nAVERAGE TIME: %.2f seconds per move\n",
total_time / movenum);
fprintf(stderr, "\nTOTAL TIME: %.2f seconds\n",
total_time);
}
/* play_gmp() does not return to main(), therefore the score
* writing code is here.
*/
{
float score = gnugo_estimate_score(NULL, NULL);
sgfWriteResult(sgftree.root, score, 1);
}
sgffile_output(&sgftree);
if (!simplified) {
/* We hang around here until cgoban asks us to go, since
* sometimes cgoban crashes if we exit first.
*
* FIXME: Check if this is still needed. I made it dependand on
* `simplifed' just to avoid changes in GMP mode.
*/
while (1) {
message = gmp_check(ge, 1, &j, &i, &error);
if (!quiet)
fprintf(stderr, "Message %d from gmp\n", message);
if (message == gmp_err)
break;
}
}
#if ORACLE
if (metamachine && oracle_exists)
dismiss_oracle();
#endif
if (!quiet)
fprintf(stderr, "gnugo going down\n");
}
void
play_solo(Gameinfo *gameinfo, int moves)
{
SGFTree sgftree;
int passes = 0; /* num. consecutive passes */
float move_value;
double t1, t2;
int save_moves = moves;
struct stats_data totalstats;
int total_owl_count = 0;
/* It tends not to be very imaginative in the opening,
* so we scatter a few stones randomly to start with.
* We add two random numbers to reduce the probability
* of playing stones near the edge.
*/
int n = 6 + 2*gg_rand()%5;
int i, j;
komi = 5.5;
sgftree_clear(&sgftree);
sgftreeCreateHeaderNode(&sgftree, board_size, komi, handicap);
sgf_write_header(sgftree.root, 1, get_random_seed(), 5.5, handicap,
get_level(), chinese_rules);
/* Generate some random moves. */
if (board_size > 6) {
do {
do {
i = (gg_rand() % 4) + (gg_rand() % (board_size - 4));
j = (gg_rand() % 4) + (gg_rand() % (board_size - 4));
} while (!is_allowed_move(POS(i, j), gameinfo->to_move));
gnugo_play_move(POS(i, j), gameinfo->to_move);
sgftreeAddPlay(&sgftree, gameinfo->to_move, i, j);
sgftreeAddComment(&sgftree, "random move");
gameinfo->to_move = OTHER_COLOR(gameinfo->to_move);
} while (--n > 0);
}
t1 = gg_cputime();
memset(&totalstats, '\0', sizeof(totalstats));
while (passes < 2 && --moves >= 0) {
int move;
reset_owl_node_counter();
move = genmove(gameinfo->to_move, &move_value, NULL);
gnugo_play_move(move, gameinfo->to_move);
sgffile_add_debuginfo(sgftree.lastnode, move_value);
sgftreeAddPlay(&sgftree, gameinfo->to_move, I(move), J(move));
sgffile_output(&sgftree);
gameinfo->to_move = OTHER_COLOR(gameinfo->to_move);
if (move == PASS_MOVE) {
passes++;
printf("%s(%d): Pass\n", gameinfo->to_move == BLACK ? "Black" : "White",
movenum);
}
else {
passes = 0;
gprintf("%s(%d): %1m\n", gameinfo->to_move == BLACK ? "Black" : "White",
movenum, move);
}
totalstats.nodes += stats.nodes;
totalstats.read_result_entered += stats.read_result_entered;
totalstats.read_result_hits += stats.read_result_hits;
totalstats.trusted_read_result_hits += stats.trusted_read_result_hits;
total_owl_count += get_owl_node_counter();
}
t2 = gg_cputime();
/* Two passes and it's over. (EMPTY == BOTH) */
who_wins(EMPTY, stdout);
{
float score = gnugo_estimate_score(NULL, NULL);
sgfWriteResult(sgftree.root, score, 1);
}
sgffile_output(&sgftree);
printf("%10d moves played in %0.3f seconds\n", save_moves-moves, t2-t1);
if (save_moves != moves)
printf("%10.3f seconds/move\n", (t2-t1)/(save_moves-moves));
printf("%10d nodes\n", totalstats.nodes);
printf("%10d read results entered\n", totalstats.read_result_entered);
printf("%10d read result hits\n", totalstats.read_result_hits);
printf("%10d trusted read result hits\n",
totalstats.trusted_read_result_hits);
printf("%10d owl nodes\n", total_owl_count);
}
void worker(worker_args_t *args)
{
int i;
for (i = 0; i < args->iterations; ++i)
(args->results.totals[who_wins(args->player1_threshold, args->player2_threshold)])++;
}
/* ascii_count() scores the game.
*/
static void
ascii_count(Gameinfo *gameinfo)
{
char line[12];
int done = 0;
int i;
int xyzzy = 1;
printf("\nGame over. Let's count!.\n");
showdead = 1;
ascii_showboard();
while (!done) {
printf("Dead stones are marked with small letters (x,o).\n");
printf("\nIf you don't agree, enter the location of a group\n");
printf("to toggle its state or \"done\".\n");
if (!fgets(line, 12, stdin))
return; /* EOF or some error */
for (i = 0; i < 12; i++)
line[i] = tolower((int) line[i]);
if (!strncmp(line, "done", 4))
done = 1;
else if (!strncmp(line, "quit", 4))
return;
else if (!strncmp(line, "xyzzy", 5)) {
if (xyzzy) {
printf("\nYou are in a debris room filled with stuff washed in from the\n");
printf("surface. A low wide passage with cobbles becomes plugged\n");
printf("with mud and debris here, but an awkward canyon leads\n");
printf("upward and west. A note on the wall says:\n");
printf(" Magic Word \"XYZZY\"\n\n");
xyzzy = 0;
}
else {
printf("You are inside a building, a well house for a large spring.\n\n");
xyzzy = 1;
}
}
else if (!strncmp(line, "help", 4)) {
printf("\nIf there are dead stones on the board I will remove them.\n");
printf("You must tell me where they are. Type the coordinates of a\n");
printf("dead group, or type \"done\"\n");
}
else if (!strncmp(line, "undo", 4)) {
printf("UNDO not allowed anymore. The status of the stones now\n");
printf("toggles after entering the location of it.\n");
ascii_showboard();
}
else {
int pos = string_to_location(board_size, line);
if (pos == NO_MOVE || board[pos] == EMPTY)
printf("\ninvalid!\n");
else {
enum dragon_status status = dragon_status(pos);
status = (status == DEAD) ? ALIVE : DEAD;
change_dragon_status(pos, status);
ascii_showboard();
}
}
}
who_wins(gameinfo->computer_player, stdout);
}
/* Communicates with user after a game has ended. */
static int
ascii_endgame(Gameinfo *gameinfo, int reason)
{
char line[80];
char *line_ptr;
char *command;
char *tmpstring;
int state = 0;
if (reason == 0) { /* Two passes, game is over. */
who_wins(gameinfo->computer_player, stdout);
printf("\nIf you disagree, we may count the game together.\n");
sgftreeWriteResult(&sgftree, (white_score + black_score)/2.0, 1);
}
else {
int color = OTHER_COLOR(gameinfo->to_move);
if (reason == 1) /* Our opponent has resigned. */
printf("GNU Go wins by resignation.\n");
else /* We have resigned. */
printf("You win by resignation.\n");
printf("Result: %c+Resign\n\n", color == WHITE ? 'W' : 'B');
sgftreeWriteResult(&sgftree, color == WHITE ? 1000.0 : -1000.0, 1);
}
while (state == 0) {
printf("You may optionally save the game as an SGF file.\n\n");
printf("Type \"save <filename>\" to save,\n");
if (reason == 0)
printf(" \"count\" to recount,\n");
else if (reason == 2)
printf(" \"continue\" to decline resignation and continue the game,\n");
printf(" \"quit\" to quit\n");
printf(" or \"game\" to play again\n");
line_ptr = line;
if (!fgets(line, 80, stdin))
break;
command = strtok(line_ptr, "");
switch (get_command(command)) {
case CMD_SAVE:
strtok(command, " ");
tmpstring = strtok(NULL, " ");
if (tmpstring) {
/* discard newline */
tmpstring[strlen(tmpstring) - 1] = 0;
init_sgf(gameinfo);
writesgf(sgftree.root, tmpstring);
}
else
printf("Please specify filename\n");
break;
case COUNT:
if (reason == 0)
ascii_count(gameinfo);
break;
case CONTINUE:
state = -1;
break;
case NEW:
state = 1;
break;
case QUIT:
state = 2;
break;
default:
state = 0;
}
}
return state;
}
