Subversion Repositories connect-6

/*

connectk -- a program to play the connect-k family of games

Copyright (C) 2007 Michael Levin

This program is free software; you can redistribute it and/or

modify it under the terms of the GNU General Public License

as published by the Free Software Foundation; either version 2

of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

*/

#include "config.h"

#include <time.h>

#include <gtk/gtk.h>

#include <glib/gprintf.h>

#include "shared.h"

#include "connectk.h"

/*

 *      Options menu

 */

int opt_det_ai = 0,

    opt_print_u = 0,

    opt_debug_dfsc = 0,

    opt_debug_thread = 0,

    opt_debug_stage = 0,

    opt_pause_ai = 0,

    opt_mark_log = 1,

    opt_mark_norm = 1,

    opt_grayscale = 0;

typedef struct {

        char *desc;

        int *pint;

        int redraw;

} Option;

/* This array contains boolean integer options which will appear as check

   menu items in the Options menu, the format is:

        { "Option name", &integer, redraw_on_toggle }, */

static Option options[] = {

        { "Pause AI",                   &opt_pause_ai,          FALSE },

        { "Deterministic AI",           &opt_det_ai,            FALSE },

        { "Print board utility",        &opt_print_u,           FALSE },

        { "Debug search path",          &opt_debug_dfsc,        FALSE },

        { "Debug threat stage",         &opt_debug_stage,       FALSE },

        { "Debug threads",              &opt_debug_thread,      FALSE },

        { "Logarithmic marking",        &opt_mark_log,          TRUE  },

        { "Normalized marking",         &opt_mark_norm,         TRUE  },

        { "Grayscale rendering",        &opt_grayscale,         TRUE  },

};

#define OPTIONS (sizeof (options) / sizeof (options[0]))

static void option_menu_item_toggled(GtkCheckMenuItem *item,

                                     gpointer user_data)

{

        Option *option = (Option*)user_data;

        *option->pint = !(*option->pint);

        gtk_check_menu_item_set_active(item, *option->pint);

        if (option->redraw)

                draw_board();

}

static void add_options_to_menu_shell(GtkWidget *menu)

{

        GtkWidget *item;

        int i;

        for(i = 0; i < OPTIONS; i++) {

                item = gtk_check_menu_item_new_with_mnemonic(options[i].desc);

                gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),

                                               *(options[i].pint));

                g_signal_connect(item, "toggled",

                                 G_CALLBACK(option_menu_item_toggled),

                                 options + i);

                gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);

        }

}

/*

 *      Window widgets

 */

typedef struct {

        PIECE type;

        PLAYER player;

} PlayerMenuItem;

static GtkWidget *statusbar = NULL, *tree_view = NULL, *window = NULL;

static GtkListStore *list_store;

// Change window statusbar text

void window_status(const char *msg)

{

        static int context;

        if (!statusbar)

                return;

        if (context)

                gtk_statusbar_pop(GTK_STATUSBAR(statusbar), context);

        context = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar),

                                               "default");

        gtk_statusbar_push(GTK_STATUSBAR(statusbar), context, msg);

}

// Set the correct settings for a move state

void setup_move(void)

{

        if (!tournament) {

                draw_marks(NULL, TRUE);

                /* Stop a draw game */

                if (move_no >= board_size * board_size) {

                        window_status(va("Draw in %d moves", move_no));

                        draw_playable(FALSE);

                        return;

                }

                /* Stop a won game */

                if (board->won) {

                        draw_playable(FALSE);

                        draw_win();

                        window_status(va("%s wins in %d moves (%s -> %s)",

                                         piece_to_string(board->turn), move_no,

                                         bcoords_to_string(board->win_x1,

                                                           board->win_y1),

                                         bcoords_to_string(board->win_x2,

                                                           board->win_y2)));

                        return;

                }

                /* Status bar message */

                if (!move_no)

                        window_status(va("Game start: %s to play "

                                         "(%d move%s left)",

                                         piece_to_string(board->turn),

                                         board->moves_left,

                                         board->moves_left == 1 ? "" : "s"));

                else

                        window_status(va("Move %d: %s to play (%d move%s left)",

                                         move_no, piece_to_string(board->turn),

                                         board->moves_left,

                                         board->moves_left == 1 ? "" : "s"));

                draw_playable(players[board->turn].ai == PLAYER_HUMAN);

        }

        /* Let the AI thread run one move */

        start_ai();

}

// Tree view cursor changed

static void cursor_changed(GtkTreeView *tree_view, gpointer user_data)

{

        GtkTreeSelection *selection;

        GtkTreeIter iter;

        GtkTreePath *path;

        gint *indices;

        selection = gtk_tree_view_get_selection(tree_view);

        gtk_tree_selection_get_selected(selection, NULL, &iter);

        path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter);

        indices = gtk_tree_path_get_indices(path);

        indices += gtk_tree_path_get_depth(path) - 1;

        if (*indices == move_no)

                return;

        go_to_move(*indices);

        gtk_tree_path_free(path);

        draw_board();

        stop_ai();

        setup_move();

}

// Clear moves in the history list

void tree_view_clear(unsigned int from)

{

        GtkTreeIter iter;

        GtkTreeSelection *selection;

        gboolean valid;

        if (!tree_view)

                return;

        g_signal_handlers_block_by_func(G_OBJECT(tree_view), cursor_changed,

                                        NULL);

        // Remove entries from list store

        valid = gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store),

                                              &iter, NULL, from);

        while (valid)

                valid = gtk_list_store_remove(list_store, &iter);

        // Select start entry

        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));

        gtk_tree_model_get_iter_first(GTK_TREE_MODEL(list_store), &iter);

        gtk_tree_selection_select_iter(selection, &iter);

        g_signal_handlers_unblock_by_func(G_OBJECT(tree_view), cursor_changed,

                                          NULL);

}

// Make a move for the current player

void make_move(BCOORD x, BCOORD y)

{

        GtkTreeIter iter;

        GtkTreePath *path;

        GtkTreeSelection *selection;

        PIECE last_turn;

        if (piece_at(board, x, y) != PIECE_NONE) {

                g_warning("%s attempted invalid move to %s",

                          piece_to_string(board->turn),

                          bcoords_to_string(x, y));

                return;

        }

        if (!tournament) {

                clear_last_moves();

                // Remove the later moves from the list

                if (move_no < move_last) {

                        clear_history(move_no + 1);

                        tree_view_clear(move_no + 1);

                }

                /* Add move to list */

                gtk_list_store_append(list_store, &iter);

                gtk_list_store_set(list_store, &iter, 0, va("%c%s",

                                   piece_to_char(board->turn),

                                   bcoords_to_string(x, y)), -1);

                // Scroll moves list down

                path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store),

                                               &iter);

                gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(tree_view), path,

                                             NULL, FALSE, 0., 0.);

                gtk_tree_path_free(path);

                // Select last move

                selection =

                          gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));

                g_signal_handlers_block_by_func(G_OBJECT(tree_view),

                                                cursor_changed, NULL);

                gtk_tree_selection_select_iter(selection, &iter);

                g_signal_handlers_unblock_by_func(G_OBJECT(tree_view),

                                                  cursor_changed, NULL);

        }

        // Place piece

        board->move_x = x;

        board->move_y = y;

        last_turn = board->turn;

        go_to_move(++move_no);

        place_piece(board, x, y);

        if (!tournament)

                draw_tile(x, y);

        board->won = check_win_full(board, x, y,

                                    &board->win_x1, &board->win_y1,

                                    &board->win_x2, &board->win_y2);

        if (!board->won) {

                board->moves_left--;

                if (board->moves_left <= 0) {

                        board->turn = other_player(last_turn);

                        board->moves_left = place_p;

                }

        }

        /* Tournament win conditions */

        if (tournament) {

                if (move_no >= board_size * board_size) {

                        tourney_result(PIECE_NONE, move_last);

                        return;

                }

                if (board->won) {

                        tourney_result(board->turn, move_last);

                        return;

                }

        } else

                draw_last_moves();

        setup_move();

}

// Main window closed

static void window_destroy(GtkWidget *widget, gpointer data)

{

        gtk_main_quit();

}

// Create a menu bar the old-fashioned way

static GtkWidget *window_menu_bar_init(GtkAccelGroup *accel)

{

        GtkWidget *bar, *item, *submenu;

        bar = gtk_menu_bar_new();

        /* Init player dialogs */

        player_dialog_init(player_dialog, PIECE_BLACK);

        player_dialog_init(player_dialog + 1, PIECE_WHITE);

        player_dialog_init(player_dialog + 2, PIECE_NONE);

        // Game menu

        item = gtk_menu_item_new_with_mnemonic("_Game");

        gtk_menu_shell_append(GTK_MENU_SHELL(bar), item);

        submenu = gtk_menu_new();

        gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);

        item = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, accel);

        g_signal_connect(G_OBJECT(item), "activate",

                         G_CALLBACK(open_new_game_dialog), NULL);

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

        item = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, accel);

        g_signal_connect(G_OBJECT(item), "activate",

                         G_CALLBACK(open_file_dialog), NULL);

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

        item = gtk_separator_menu_item_new();

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

        item = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE_AS, accel);

        g_signal_connect(G_OBJECT(item), "activate",

                         G_CALLBACK(save_file_dialog), NULL);

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

#ifndef NO_CAIRO_SVG

        item = gtk_separator_menu_item_new();

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

        item = gtk_menu_item_new_with_mnemonic("Screenshot");

        g_signal_connect(G_OBJECT(item), "activate",

                         G_CALLBACK(screenshot_dialog), NULL);

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

#endif

        item = gtk_separator_menu_item_new();

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

        // Game -> Quit

        item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, accel);

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

        g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(window_destroy),

                         NULL);

        /* Setup menu */

        item = gtk_menu_item_new_with_mnemonic("_Setup");

        gtk_menu_shell_append(GTK_MENU_SHELL(bar), item);

        submenu = gtk_menu_new();

        gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);

        item = gtk_menu_item_new_with_mnemonic("_Black Player");

        g_signal_connect(G_OBJECT(item), "activate",

                         G_CALLBACK(open_player_dialog), player_dialog);

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

        item = gtk_menu_item_new_with_mnemonic("_White Player");

        g_signal_connect(G_OBJECT(item), "activate",

                         G_CALLBACK(open_player_dialog), player_dialog + 1);

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

        item = gtk_menu_item_new_with_mnemonic("_Mark Player");

        g_signal_connect(G_OBJECT(item), "activate",

                         G_CALLBACK(open_player_dialog), player_dialog + 2);

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

        item = gtk_separator_menu_item_new();

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

        item = gtk_menu_item_new_with_mnemonic("_Tournament");

        g_signal_connect(G_OBJECT(item), "activate",

                         G_CALLBACK(open_tourney_dialog), NULL);

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

        item = gtk_separator_menu_item_new();

        gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);

        add_options_to_menu_shell(submenu);

        /* Tests menu */

        item = gtk_menu_item_new_with_mnemonic("_Tests");

        gtk_menu_shell_append(GTK_MENU_SHELL(bar), item);

        submenu = gtk_menu_new();

        add_tests_to_menu_shell(submenu);

        gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);

        return bar;

}

// Create a tree view to store the move history

static GtkWidget *tree_view_init(void)

{

        GtkWidget *scrolled;

        GtkTreeViewColumn *column;

        GtkTreeSelection *selection;

        GtkTreeIter iter;

        if (tree_view)

                return tree_view;

        // Tree view to list move history

        list_store = gtk_list_store_new(1, G_TYPE_STRING);

        tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store));

        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));

        gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);

        gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree_view), TRUE);

        column = gtk_tree_view_column_new_with_attributes("History",

                                                   gtk_cell_renderer_text_new(),

                                                          "text", 0, NULL);

        gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);

        g_signal_connect(G_OBJECT(tree_view), "cursor-changed",

                         G_CALLBACK(cursor_changed), NULL);

        // Add empty board entry to history list

        gtk_list_store_append(list_store, &iter);

        gtk_list_store_set(list_store, &iter, 0, "(start)", -1);

        // Scrolled container for tree view

        scrolled = gtk_scrolled_window_new(NULL, NULL);

        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),

                                       GTK_POLICY_NEVER,

                                       GTK_POLICY_AUTOMATIC);

        gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),

                                            GTK_SHADOW_IN);

        gtk_container_add(GTK_CONTAINER(scrolled), tree_view);

        return scrolled;

}

// Create and show main window

static void window_init(void)

{

        GtkWidget *hbox, *vbox;

        GtkAccelGroup *accel;

        if (window)

                return;

        // Keyboard accelerator group

        accel = gtk_accel_group_new();

        // Menu, hbox, and status bar are packed vertically

        vbox = gtk_vbox_new(FALSE, 0);

        gtk_box_pack_start(GTK_BOX(vbox), window_menu_bar_init(accel), FALSE,

                           FALSE, 0);

        statusbar = gtk_statusbar_new();

        gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);

        // Board and history are packed horizontally

        hbox = gtk_hbox_new(FALSE, 0);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);

        gtk_box_pack_start(GTK_BOX(hbox), draw_init(), TRUE, TRUE, 0);

        gtk_box_pack_start(GTK_BOX(hbox), tree_view_init(), FALSE, FALSE, 0);

        // Create and show the window

        window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

        g_signal_connect(G_OBJECT(window), "destroy",

                         G_CALLBACK(window_destroy), NULL);

        gtk_window_set_title(GTK_WINDOW(window), "connectk");

        gtk_window_resize(GTK_WINDOW(window), 686, 656);

        gtk_window_add_accel_group(GTK_WINDOW(window), accel);

        gtk_container_add(GTK_CONTAINER(window), vbox);

        gtk_widget_show_all(window);

        // Create new game dialog

        new_game_dialog_init();

        /* Initialize tournament dialog */

        tourney_dialog_init();

}

/*

 *      Utility and main

 */

char *nvav(int *plen, const char *fmt, va_list va)

{

        static char buffer[2][16000];

        static int which;

        int len;

        which = !which;

        len = g_vsnprintf(buffer[which], sizeof(buffer[which]), fmt, va);

        if (plen)

                *plen = len;

        return buffer[which];

}

char *nva(int *plen, const char *fmt, ...)

{

        va_list va;

        char *string;

        va_start(va, fmt);

        string = nvav(plen, fmt, va);

        va_end(va);

        return string;

}

char *va(const char *fmt, ...)

{

        va_list va;

        char *string;

        va_start(va, fmt);

        string = nvav(NULL, fmt, va);

        va_end(va);

        return string;

}

int main(int argc, char *argv[])

{

        start_ai_thread();

        new_game(19);

        /* Set the Glib random seed */

        g_random_set_seed(time(NULL));

        /* Initialize and run the GTK interface */

        gtk_init(&argc, &argv);

        window_init();

        gtk_main();

        return 0;

}