main.c

经典的俄罗斯方块程序

#include<stdlib.h>
#include<gtk/gtk.h>
#include<libintl.h>
#include<locale.h>
#include"main.h"
#include"drawboard.h"
#include"module_act.h"
#include"time_tick.h"
#include"clean_line.h"
#include"about_message.h"

extern GdkPixbuf* image;
extern gint*      board1[COLUMN1];
extern gint*      board2[COLUMN2];
extern pmodule    module;
extern gboolean   ispause;

GtkWidget* lscore;
GtkWidget* lrow;
GtkWidget* llevel;

gint score=0;
gint row  =0;
gint level=1;
gint timerid;
gint timespace=TIME_SPACE;

static gint blockWidth=0;

    
static gboolean
stop_the_app(GtkWidget* widget,gpointer data)
{
    gtk_main_quit();
    
    return TRUE;
}

static void
board_configure1(GtkWidget* widget,
                 gpointer data)
{
    drawboard_init(widget,
                   COLUMN1,ROW1,
                   blockWidth,1);
    
}

static void
board_configure2(GtkWidget* widget,
                 gpointer data)
{
    drawboard_init(widget,
                   COLUMN2,ROW2,
                   blockWidth*2/3,2);
}

static gboolean
expose_event1(GtkWidget* widget,
              gpointer data)
{
    return drawboard_expose(widget,
                            1,NULL);
}

static gboolean
expose_event2(GtkWidget* widget,
              gpointer data)
{
    return drawboard_expose(widget,
                            2,NULL);
}


static gboolean
app_start(GtkWidget* widget,
          gpointer data)
{
    if(0==timerid){
         /* Declared in time_tick.h */
        time_tick_init(GTK_WIDGET(data));
        timerid=g_timeout_add(timespace,
                              time_tick,
                              GTK_WIDGET(data));
    }
    ispause=FALSE;
    
    return TRUE;
}

static gboolean
app_pause(GtkWidget* widget,
          gpointer   data)
{
    ispause=TRUE;
    
    return TRUE;
}

static gboolean
stop_the_game(GtkWidget* widget,
              gpointer   data)
{
    renew_the_app(GTK_WIDGET(data));
    
    return TRUE;
}


static gboolean
create_buttons(GtkWidget* window,
               GtkWidget* box)
{
    GtkWidget* lbox;
    GtkWidget* bstart;
    GtkWidget* bpause;
    GtkWidget* bstop;
    GtkWidget* bquit;

    bquit =gtk_button_new_with_label(_("Quit"));
    bstop =gtk_button_new_with_label(_("Stop"));
    bpause=gtk_button_new_with_label(_("Pause"));
    bstart=gtk_button_new_with_label(_("Start"));

    gtk_box_pack_end_defaults(GTK_BOX(box),
                              bquit);
    gtk_box_pack_end_defaults(GTK_BOX(box),
                              bstop);
    gtk_box_pack_end_defaults(GTK_BOX(box),
                              bpause);
    gtk_box_pack_end_defaults(GTK_BOX(box),
                              bstart);

    gtk_signal_connect(GTK_OBJECT(bstart),
                       "clicked",
                       GTK_SIGNAL_FUNC(app_start),
                       window);
    gtk_signal_connect(GTK_OBJECT(bpause),
                       "clicked",
                       GTK_SIGNAL_FUNC(app_pause),
                       window);
    gtk_signal_connect(GTK_OBJECT(bquit),
                       "clicked",
                       GTK_SIGNAL_FUNC(stop_the_app),
                       NULL);
    gtk_signal_connect(GTK_OBJECT(bstop),
                       "clicked",
                       GTK_SIGNAL_FUNC(stop_the_game),
                       window);
    
    lscore=gtk_label_new(_("score: 0"));
    lrow  =gtk_label_new(_("row  : 0"));
    llevel=gtk_label_new(_("level: 1"));

    lbox=gtk_vbox_new(FALSE,5);
    
    gtk_box_pack_end_defaults(GTK_BOX(lbox),
                              llevel);
    gtk_box_pack_end_defaults(GTK_BOX(lbox),
                              lrow);
    gtk_box_pack_end_defaults(GTK_BOX(lbox),
                              lscore);
    gtk_box_pack_end_defaults(GTK_BOX(box),
                              lbox);
    
    return TRUE;
}

static gboolean
key_release_answer(GtkWidget* widget,
                   GdkEventKey* key,
                   gpointer data)
{
    switch(key->keyval){
        case 65364:
            break;
        default:
            break;
    }
    
    return TRUE;
}

static gboolean
key_press_answer(GtkWidget* widget,
                 GdkEventKey* key,
                 gpointer data)
{
    gint keyval=key->keyval;
    
    if(ispause&&keyval!=115&&keyval!=113&&keyval!=83&&keyval!=81)   /* */
        return TRUE;
    
    switch(key->keyval){
        case 113:
        case 81:
            stop_the_app(NULL,NULL);
            break;
        case 112:
        case 80:
            ispause=TRUE;
            break;
        case 83:
        case 115:
            if(0==timerid){
         /* Declared in time_tick.h */
                time_tick_init(GTK_WIDGET(widget));
                timerid=g_timeout_add(timespace,
                                      time_tick,
                                      GTK_WIDGET(widget));
            }
            ispause=FALSE;
            break;
        case 65362:                 /* up */
            module_rotate(module);
            draw_mod_board1(module);
            drawboard_draw(widget,
                           board1,
                           COLUMN1,
                           ROW1,
                           1);
            break;
        case 65361:                 /* left */
            module_left(module);
            draw_mod_board1(module);
            drawboard_draw(widget,
                           board1,
                           COLUMN1,
                           ROW1,
                           1);
            break;
        case 65363:                 /* right */
            module_right(module);
            draw_mod_board1(module);
            drawboard_draw(widget,
                           board1,
                           COLUMN1,
                           ROW1,
                           1);
            break;
        case 65364:                 /* down */
            time_tick(widget);
            break;
        case 32:
            module_direct_down(widget,
                               module);
            draw_mod_board1(module);
            drawboard_draw(widget,
                           board1,
                           COLUMN1,
                           ROW1,
                           1);
            break;
        default:
            break;
    }
    
    return TRUE;
}


static gboolean
create_menu(GtkWidget* window,
            GtkWidget* vbox)
{
    GtkWidget* label;
    GtkWidget* menubar;
    GtkWidget* gamemenuitem;
    GtkWidget* helpmenuitem;
    GtkWidget* menu;
    GtkWidget* item;
    
    menubar=gtk_menu_bar_new();
    gtk_box_pack_start_defaults(GTK_BOX(vbox),
                                menubar);
    gamemenuitem=gtk_menu_item_new_with_label(_("Game"));
    helpmenuitem=gtk_menu_item_new_with_label(_("Help"));
    
    gtk_menu_bar_append(GTK_MENU_BAR(menubar),
                        gamemenuitem);
    gtk_menu_bar_append(GTK_MENU_BAR(menubar),
                        helpmenuitem);
    
    menu=gtk_menu_new();
    item=gtk_menu_item_new_with_label(_("Start"));
    gtk_menu_append(GTK_MENU(menu),item);
    gtk_signal_connect(GTK_OBJECT(item),
                       "activate",
                       GTK_SIGNAL_FUNC(app_start),
                       window);
    
    item=gtk_menu_item_new_with_label(_("Pause     "));
    gtk_menu_append(GTK_MENU(menu),item);
    gtk_signal_connect(GTK_OBJECT(item),
                       "activate",
                       GTK_SIGNAL_FUNC(app_pause),
                       window);
    
    item=gtk_menu_item_new_with_label(_("Stop"));
    gtk_menu_append(GTK_MENU(menu),item);
    gtk_signal_connect(GTK_OBJECT(item),
                       "activate",
                       GTK_SIGNAL_FUNC(stop_the_game),
                       window);
    
    item=gtk_menu_item_new_with_label(_("Quit"));
    gtk_menu_append(GTK_MENU(menu),item);
    gtk_signal_connect(GTK_OBJECT(item),
                       "activate",
                       GTK_SIGNAL_FUNC(stop_the_app),
                       window);
    
    
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(gamemenuitem),menu);
    
    menu=gtk_menu_new();
    item=gtk_menu_item_new_with_label(_("About      "));
    gtk_menu_append(GTK_MENU(menu),item);
    gtk_signal_connect(GTK_OBJECT(item),
                       "activate",
                       GTK_SIGNAL_FUNC(show_about_message),
                       window);
    
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(helpmenuitem),menu);
    
    return TRUE;
}


static gboolean
init_interface(GtkWidget* window)
{
    GtkWidget* hbox;
    GtkWidget* vbox;
    GtkWidget* canvas1;
    GtkWidget* canvas2;
    GtkWidget* test;

    gchar fname[]="pixmaps/colors.png";

    vbox=gtk_vbox_new(FALSE,5);
    gtk_container_add(GTK_CONTAINER(window),
                      vbox);
    
    hbox=gtk_hbox_new(FALSE,5);
//    gtk_container_add(GTK_CONTAINER(window),hbox);
    gtk_box_pack_end_defaults(GTK_BOX(vbox),
                              hbox);
    create_menu(window,vbox);
    
    vbox=gtk_vbox_new(FALSE,5);
    gtk_box_pack_end_defaults(GTK_BOX(hbox),
                              vbox);
        
    image=gdk_pixbuf_new_from_file(fname,
                                   NULL);
    if(NULL==image){
        g_print(_("Fail to open file: %s\n"),fname);
        exit(0);
    }
    
    blockWidth=gdk_pixbuf_get_width(image)/3;

    canvas1=gtk_drawing_area_new();
    gtk_drawing_area_size(GTK_DRAWING_AREA(canvas1),
                          blockWidth*COLUMN1,
                          blockWidth*ROW1);

    gtk_box_pack_end_defaults(GTK_BOX(hbox),
                              canvas1);
    
    gtk_signal_connect(GTK_OBJECT(canvas1),
                       "configure_event",
                       GTK_SIGNAL_FUNC(board_configure1),
                       canvas1);
    gtk_signal_connect(GTK_OBJECT(canvas1),
                       "expose_event",
                       GTK_SIGNAL_FUNC(expose_event1),
                       NULL);
    
    canvas2=gtk_drawing_area_new();
    gtk_drawing_area_size(GTK_DRAWING_AREA(canvas2),
                          blockWidth*2/3*COLUMN2,
                          blockWidth*2/3*ROW2);

    gtk_box_pack_start_defaults(GTK_BOX(vbox),
                                canvas2);
    
    gtk_signal_connect(GTK_OBJECT(canvas2),
                       "configure_event",
                       GTK_SIGNAL_FUNC(board_configure2),
                       canvas2);
    gtk_signal_connect(GTK_OBJECT(canvas2),
                       "expose_event",
                       GTK_SIGNAL_FUNC(expose_event2),
                       NULL);
    
    gtk_signal_connect(GTK_OBJECT(window),
                       "key_press_event",
                       GTK_SIGNAL_FUNC(key_press_answer),
                       NULL);
    gtk_signal_connect(GTK_OBJECT(window),
                       "key_release_event",
                       GTK_SIGNAL_FUNC(key_release_answer),
                       NULL);
    
    create_buttons(window,vbox);
    
    return TRUE;
}

static gboolean
create_app(void)
{
    gint i,j;
    GtkWidget* window;

    
    srand(time(0));
    
    for(i=0;i<COLUMN1;i++){
        board1[i]=&_board1[i*ROW1];
    }
    for(i=0;i<COLUMN2;i++){
        board2[i]=&_board2[i*ROW2];
    }
    
    window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window),
                         _("Teris Game"));
    gtk_window_set_position(GTK_WINDOW(window),
                            GTK_WIN_POS_CENTER);

    gtk_window_set_resizable(GTK_WINDOW(window),
                             FALSE);
    gtk_container_set_border_width(GTK_CONTAINER(window),
                                   0);
    
    gtk_signal_connect(GTK_OBJECT(window),
                       "destroy",
                       GTK_SIGNAL_FUNC(stop_the_app),
                       NULL);

    init_interface(window);
    gtk_widget_show_all(window);
    
    
    return TRUE;
}

gint main(gint argc,gchar* argv[])
{
    gtk_init(&argc,&argv);

    setlocale(LC_ALL,"");
    bindtextdomain("tetri","./po");
    textdomain("tetri");
    
    if(create_app()){
        gtk_main();
    }

    return 0;
}