테트리스입니다.분석좀부탁드립니다.

#include
#include
#include

gint nx_one, ny_one, tx, ty, nowbl_one, nowrot_one, nowbcol_one;
gint nx_two, ny_two, nowbl_two, nowrot_two, nowbcol_two;
gint bk_gnd1[15][21];
gint bk_gnd2[15][24];
gint timer_one, timer_two;
gint score_one, score_two;
gint tetflag;
gint oneflag;
gint twoflag;
gint speed_one[8] = {1000, 8000, 600, 350, 150, 50, 10, 5};

/*- 블럭의 x 좌표(7종류 모양의 블럭이 각각 4가지 회전 형태를 가진
다) -*/
gint block_x[28][7] = {{-10, 0, 10, 20},
{0, 0, 10, 10},
{0, 10, 20, 20},
{0, 0, 10, 20},
{0, 10, 10, 20},
{0, 10, 10, 20},
{0, 10, 10, 20},

{0, 0, 0, 0},
{0, 0, 10, 10},
{10, 20, 20, 20},
{0, 10, 10, 10},
{10, 20, 20, 20},
{10, 10, 20, 20},
{10, 10, 20, 20},

{-10, 0, 10, 20},
{0, 0, 10, 10},
{0, 0, 10, 20},
{0, 10, 20, 20},
{0, 10, 10, 20},
{0, 10, 10, 20},
{0, 10, 10, 20},

{0, 0, 0, 0},
{0, 0, 10, 10},
{10, 10, 10, 20},
{10, 10, 10, 20},
{10, 10, 10, 20},
{10, 10, 20, 20},
{10, 10, 20, 20}};

/*- 블럭의 y 좌표(7종류 모양의 블럭이 각각 4가지 회전 형태를 가진
다) -*/
gint block_y[28][7] = {{10, 10, 10, 10},
{0, 10, 0, 10},
{10, 10, 0, 10},
{0, 10, 10, 10},
{10, 0, 10, 10},
{0, 0, 10, 10},
{10, 0, 10, 0},

{-10, 0, 10, 20},
{0, 10, 0, 10},
{-10, -10, 0, 10},
{10, -10, 0, 10},
{0, -10, 0, 10},
{0, 10, -10, 0},
{-10, 0, 0, 10},

{10, 10, 10, 10},
{0, 10, 0, 10},
{0, 10, 0, 0},
{0, 0, 0, 10},
{0, 0, 10, 0},
{0, 0, 10, 10},
{10, 0, 10, 0},

{-10, 0, 10, 20},
{0, 10, 0, 10},
{-10, 0, 10, 10},
{-10, 10, 0, -10},
{-10, 0, 10, 0},
{0, 10, -10, 0},
{-10, 0, 0, 10}};

/* 0black, 1mentcream, 2orangered, 3navyblue
* 4lightgreen, 5yellow, 6lightpink */
GdkColormap *col_mp;
GdkPixmap *pix_m1, *pix_m2;
GdkColor color[7];
GtkWidget *wor_a1, *wor_a2;
GdkGC *tet_bl, *tet_br;

void program_quit(GtkButton *, gpointer);
void draw_bgleft(void);
void draw_bgright(void);
void cstetris(void);
void key_press(GtkWidget *, GdkEventKey *);
void key_press_two(GtkWidget *, GdkEventKey *);
void draw_block_one(gint, gint);
gint down_move_one(void);
void game_loop(gint, gint);
void restore_bg(void); /*- 배경배열 초기화 -*/
void left_move_one(void);
void right_move_one(void);
void rotate_move_one(void);
void is_full_one(void);
void res_bg_one(void);
void res_bg_two(void);
void draw_block_two(gint, gint);
gint down_move_two(void);
void restore_bg_two(void); /*- 배경배열 초기화 -*/
void left_move_two(void);
void right_move_two(void);
void rotate_move_two(void);
void is_full_two(void);
void onetris(void);
void twotris(void);
void print_score(gint, gint);

gint what_around_one(gint);
gint what_around_two(gint);

gboolean delete_handler(GtkWidget *, GdkEvent *, gpointer);
gboolean expose_handler(GtkWidget *, GdkEventExpose *, gpointer);

int main(int argc, char *argv[])
{
GtkWidget *top_wn, *ver_bx, *hor_bx, *mnu_br, *srt_bt,
*frm_a1, *abt_lb;
GtkWidget *cnt_bt, *abu_bt, *ext_bt, *ent_wn, *frm_a2,
*abt_dl, *abt_ok;

gtk_init(&argc, &argv);

col_mp = gdk_colormap_get_system();



/*-------------------------------------------------------*/
gdk_color_parse("Black", &color[0]);
gdk_color_parse("MintCream", &color[1]);
gdk_color_parse("OrangeRed", &color[2]);
gdk_color_parse("Violet", &color[3]);
gdk_color_parse("Green", &color[4]);
gdk_color_parse("Yellow", &color[5]);
gdk_color_parse("LightPink", &color[6]);
/*------------------------------------------------------*/

top_wn = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_policy(GTK_WINDOW(top_wn), FALSE, FALSE,
TRUE);
gtk_window_set_title(GTK_WINDOW(top_wn), "C&S's tetris");
gtk_signal_connect(GTK_OBJECT(top_wn), "delete-event",
GTK_SIGNAL_FUNC(delete_handler), NULL);

ver_bx = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(ver_bx), 5);
gtk_container_add(GTK_CONTAINER(top_wn), ver_bx);

mnu_br = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(ver_bx), mnu_br, FALSE, FALSE,
0);

hor_bx = gtk_hbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(hor_bx), 5);
gtk_container_add(GTK_CONTAINER(ver_bx), hor_bx);

srt_bt = gtk_menu_item_new_with_label("one_player");
gtk_menu_bar_append(GTK_MENU_BAR(mnu_br), srt_bt);
gtk_signal_connect(GTK_OBJECT(srt_bt), "activate",
onetris, NULL);

cnt_bt = gtk_menu_item_new_with_label("two_player");
gtk_menu_bar_append(GTK_MENU_BAR(mnu_br), cnt_bt);
gtk_signal_connect(GTK_OBJECT(cnt_bt), "activate",
twotris, NULL);

abu_bt = gtk_menu_item_new_with_label("About");
gtk_menu_bar_append(GTK_MENU_BAR(mnu_br), abu_bt);

ext_bt = gtk_menu_item_new_with_label(" Exit");
gtk_menu_bar_append(GTK_MENU_BAR(mnu_br), ext_bt);
gtk_menu_item_right_justify(GTK_MENU_ITEM(ext_bt));
gtk_signal_connect(GTK_OBJECT(ext_bt), "activate",
program_quit, NULL);

frm_a1 = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frm_a1),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(hor_bx), frm_a1, FALSE, FALSE,
1);

frm_a2 = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frm_a2),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(hor_bx), frm_a2, FALSE, FALSE,
1);


wor_a1 = gtk_drawing_area_new();
gtk_drawing_area_size(GTK_DRAWING_AREA(wor_a1), 148, 220);
gtk_container_add(GTK_CONTAINER(frm_a1), wor_a1);

wor_a2 = gtk_drawing_area_new();
gtk_drawing_area_size(GTK_DRAWING_AREA(wor_a2), 148, 220);
gtk_container_add(GTK_CONTAINER(frm_a2), wor_a2);

abt_dl = gtk_dialog_new();
abt_lb = gtk_label_new("This is a simple Twin Tetris.\n"
"\nOneplayer's key \n"
" S(s), Z(z), X(x), C(c)\n"
"\nTwoplayer's key \n"
" Up, Left, Right, Down\n"
" \n"
" C&S'sTetris ver 1.0 ");
abt_ok = gtk_button_new_with_label("OK");

gtk_box_pack_start(GTK_BOX(GTK_DIALOG(abt_dl)->vbox),
abt_lb, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(abt_dl)-
>action_area), abt_ok, FALSE, FALSE, 0);
gtk_widget_show(abt_lb);
gtk_widget_show(abt_ok);

gtk_signal_connect(GTK_OBJECT(wor_a1), "expose_event",
(GtkSignalFunc)expose_handler, NULL);
gtk_signal_connect(GTK_OBJECT(wor_a2), "expose_event",
(GtkSignalFunc)expose_handler, NULL);
gtk_signal_connect(GTK_OBJECT(top_wn), "key_press_event",
(GtkSignalFunc)key_press, NULL);
gtk_signal_connect_object(GTK_OBJECT(abu_bt), "activate",
(GtkSignalFunc)gtk_widget_show, GTK_OBJECT(abt_dl));
gtk_signal_connect_object(GTK_OBJECT(abt_ok), "clicked",
(GtkSignalFunc)gtk_widget_hide, GTK_OBJECT(abt_dl));

gtk_widget_show_all(top_wn);

gtk_main();
return 0;
}


void onetris(void)
{
tetflag = 0; score_one = 0;
if(timer_one) gtk_timeout_remove(timer_one);
if(timer_two) gtk_timeout_remove(timer_two);
cstetris();
}

void twotris(void)
{
tetflag = 1; score_one = 0; score_two = 0;
oneflag = 0; twoflag = 0;
if(timer_one) gtk_timeout_remove(timer_one);
if(timer_two) gtk_timeout_remove(timer_two);
cstetris();
}

void program_quit(GtkButton *clik, gpointer data)
{
g_free(pix_m1); g_free(pix_m2); g_free(wor_a1);
g_free(wor_a2); g_free(tet_bl);

gtk_main_quit();
}

gboolean delete_handler(GtkWidget *wigt, GdkEvent *evnt, gpointer
data)
{
return FALSE;
}

gboolean expose_handler(GtkWidget *widget, GdkEventExpose *event,
gpointer data)
{
GdkGC *tmp_gc = gdk_gc_new(widget->window);
GdkPixmap *pix_tm = gtk_object_get_data(GTK_OBJECT
(widget), "pixmap");

if(pix_tm)
gdk_draw_pixmap(widget->window, tmp_gc, pix_tm,
event->area.x, event->area.y,
event->area.x, event->area.y,
event->area.width, event->area.height);
return TRUE;
}

void key_press(GtkWidget *widget, GdkEventKey *event)
{
switch(event->keyval)
{
case GDK_Z
case GDK_z
left_move_one();
break;

case GDK_C
case GDK_c
right_move_one();
break;

case GDK_S
case GDK_s
rotate_move_one();
break;

case GDK_X
case GDK_x
while(down_move_one());
break;

default
break;
}

if(tetflag == 1)
{
switch(event->keyval)
{
case GDK_Left
left_move_two();
break;

case GDK_Right
right_move_two();
break;

case GDK_Up
rotate_move_two();
break;

case GDK_Down
while(down_move_two());
break;

default
break;
}
}
}

void cstetris()
{
gint i = 0, j = 0;
ny_one = 0;
tx= 60, ty = 10;

restore_bg();

tet_bl = gdk_gc_new(wor_a1->window);
pix_m1 = gdk_pixmap_new(wor_a1->window, 150, 220, -1);
draw_bgleft();

if(tetflag == 1)
{
tet_br = gdk_gc_new(wor_a2->window);
pix_m2 = gdk_pixmap_new(wor_a2->window, 150,
220, -1);
draw_bgright();
gtk_object_set_data(GTK_OBJECT(wor_a2), "pixmap",
pix_m2);
}

gtk_object_set_data(GTK_OBJECT(wor_a1), "pixmap", pix_m1);

game_loop(1, 1);


return;
}

void draw_bgleft()
{
gint k;

/*---------------------------------------------------------
-------*/
gdk_colormap_alloc_color(col_mp, &wor_a1->style->bg
[GTK_STATE_NORMAL], FALSE, TRUE);
gdk_gc_set_foreground(tet_bl , &wor_a1->style->bg
[GTK_STATE_NORMAL]);
gdk_draw_rectangle(pix_m1, tet_bl, TRUE, 0, 0, 148, 220);
/*---------------------------------------------------------
-------*/

/*색이 지정된 도형 벽(left)--------------------------------
-------*/
gdk_colormap_alloc_color(col_mp, &color[5], FALSE, TRUE);
gdk_gc_set_foreground(tet_bl, &color[5]);
gdk_draw_rectangle(pix_m1, tet_bl, TRUE, 4, 4, 141, 201);
/*---------------------------------------------------------
-------*/

/*색이 지정된 도형 배경(left)------------------------------
-------*/
gdk_colormap_alloc_color(col_mp, &color[0], FALSE, TRUE);
gdk_gc_set_foreground(tet_bl, &color[0]);
gdk_draw_rectangle(pix_m1, tet_bl, TRUE, 9, 9, 131, 191);
/*---------------------------------------------------------
-------*/
}

void draw_bgright()
{
tet_br = gdk_gc_new(wor_a2->window);

/*---------------------------------------------------------
-------*/
gdk_colormap_alloc_color(col_mp, &wor_a2->style->bg
[GTK_STATE_NORMAL], FALSE, TRUE);
gdk_gc_set_foreground(tet_br , &wor_a2->style->bg
[GTK_STATE_NORMAL]);
gdk_draw_rectangle(pix_m2, tet_br, TRUE, 0, 0, 148, 220);
/*---------------------------------------------------------
-------*/

/*색이 지정된 도형 벽(left)--------------------------------
-------*/
gdk_colormap_alloc_color(col_mp, &color[6], FALSE, TRUE);
gdk_gc_set_foreground(tet_br, &color[6]);
gdk_draw_rectangle(pix_m2, tet_br, TRUE, 4, 4, 141, 201);
/*---------------------------------------------------------
-------*/

/*색이 지정된 도형 배경(left)------------------------------
-------*/
gdk_colormap_alloc_color(col_mp, &color[0], FALSE, TRUE);
gdk_gc_set_foreground(tet_br, &color[0]);
gdk_draw_rectangle(pix_m2, tet_br, TRUE, 9, 9, 131, 191);
/*---------------------------------------------------------
-------*/
}

void game_loop(gint kkk, gint mmm)
{
if(kkk == 1)
{
nx_one = ny_one = 0;
srandom(time(NULL));
nowbl_one = random()%7;
nowbcol_one = random()%4+1;
nowrot_one = 0;
draw_block_one(1, nowbcol_one);

if(what_around_one(4) != 0)
{
oneflag = 1;

if(oneflag == 1 && twoflag == 1 &&
score_one < score_two)
{
gdk_colormap_alloc_color
(col_mp, &color[0], FALSE, TRUE);
gdk_gc_set_foreground(tet_br ,
&color[0]);
gdk_draw_string(pix_m2, wor_a2-
>style->font, tet_br, 100, 217, "WIN");
gdk_draw_pixmap(wor_a2->window,
tet_br, pix_m2, 0, 0, 0, 0, 150, 220);
}

if(twoflag == 1 && oneflag == 1 &&
score_one > score_two)
{
gdk_colormap_alloc_color
(col_mp, &color[0], FALSE, TRUE);
gdk_gc_set_foreground(tet_bl ,
&color[0]);
gdk_draw_string(pix_m1, wor_a1-
>style->font, tet_bl, 100, 217, "WIN");
gdk_draw_pixmap(wor_a1->window,
tet_bl, pix_m1, 0, 0, 0, 0, 150, 220);
}

return;
}
timer_one = gtk_timeout_add(speed_one
[score_one/100], (GtkFunction)down_move_one, NULL);
}

if(tetflag == 1 && mmm == 1)
{
nx_two = ny_two = 0;
srandom(time(NULL));
nowbl_two = random()%7;
nowbcol_two = random()%4+1;
nowrot_two = 0;
draw_block_two(1, nowbcol_two);

if(what_around_two(4) != 0)
{
twoflag = 1;

if(oneflag == 1 && twoflag == 1 &&
score_one < score_two)
{
gdk_colormap_alloc_color
(col_mp, &color[0], FALSE, TRUE);
gdk_gc_set_foreground(tet_br ,
&color[0]);
gdk_draw_string(pix_m2, wor_a2-
>style->font, tet_br, 100, 217, "WIN");
gdk_draw_pixmap(wor_a2->window,
tet_br, pix_m2, 0, 0, 0, 0, 150, 220);
}

if(twoflag == 1 && oneflag == 1 &&
score_one > score_two)
{
gdk_colormap_alloc_color
(col_mp, &color[0], FALSE, TRUE);
gdk_gc_set_foreground(tet_bl ,
&color[0]);
gdk_draw_string(pix_m1, wor_a1-
>style->font, tet_bl, 100, 217, "WIN");
gdk_draw_pixmap(wor_a1->window,
tet_bl, pix_m1, 0, 0, 0, 0, 150, 220);
}

return;
}

timer_two = gtk_timeout_add(speed_one
[score_two/100], (GtkFunction)down_move_two, NULL);
}
}

void draw_block_one(gint flag, gint bcol)
{
gint tmp;
gint i;

if(flag == 0)
{
gdk_colormap_alloc_color(col_mp, color, FALSE,
TRUE);
gdk_gc_set_foreground(tet_bl, color);
}

if(flag == 1)
{
gdk_colormap_alloc_color(col_mp, &color
[nowbcol_one], FALSE, TRUE);
gdk_gc_set_foreground(tet_bl, &color
[nowbcol_one]);
}

for(i=0; i < 4; i++)
{
if(ty + ny_one + block_y[nowbl_one+nowrot_one][i]
<= 0) tmp = 10;
else tmp = 0;
gdk_draw_rectangle(pix_m1, tet_bl, TRUE, tx +
nx_one + block_x[nowbl_one+nowrot_one][i],
ty
+ ny_one + tmp + block_y[nowbl_one+nowrot_one][i], 9, 9);
}

gtk_object_set_data(GTK_OBJECT(wor_a1), "pixmap", pix_m1);
gdk_draw_pixmap(wor_a1->window, tet_bl, pix_m1, 0, 0, 0,
0, 150, 220);
}

void draw_block_two(gint flag, gint bcol)
{
gint tmp;
gint i;

if(flag == 0)
{
gdk_colormap_alloc_color(col_mp, color, FALSE,
TRUE);
gdk_gc_set_foreground(tet_br, color);
}

if(flag == 1)
{
gdk_colormap_alloc_color(col_mp, &color
[nowbcol_two], FALSE, TRUE);
gdk_gc_set_foreground(tet_br, &color
[nowbcol_two]);
}

for(i=0; i < 4; i++)
{
if(ty + ny_two + block_y[nowbl_two+nowrot_two][i]
<= 0) tmp = 10;
else tmp = 0;
gdk_draw_rectangle(pix_m2, tet_br, TRUE, tx +
nx_two + block_x[nowbl_two+nowrot_two][i],
ty
+ ny_two + tmp + block_y[nowbl_two+nowrot_two][i], 9, 9);
}

gtk_object_set_data(GTK_OBJECT(wor_a2), "pixmap", pix_m2);
gdk_draw_pixmap(wor_a2->window, tet_br, pix_m2, 0, 0, 0,
0, 150, 220);
}

gint down_move_one()
{
gint i;

if(what_around_one(0) != 0)
{
is_full_one();
gtk_timeout_remove(timer_one);
game_loop(1, 0);
return 0;
}

else
{
draw_block_one(0, nowbcol_one);
ny_one += 10;
draw_block_one(1, nowbcol_one);
return 1;
}
}

gint down_move_two()
{
gint i;

if(what_around_two(0) != 0)
{
is_full_two();
gtk_timeout_remove(timer_two);
game_loop(0, 1);
return 0;
}

else
{
draw_block_two(0, nowbcol_two);
ny_two += 10;
draw_block_two(1, nowbcol_two);
return 1;
}
}

void left_move_one()
{
if(what_around_one(1) != 0) /*- 1 left 키 -*/
return; /*- 움직일 수
없으면 아무것도 실행하지 않음 -*/
draw_block_one(0, nowbcol_one); /*- 움직일 수
있으면 현재 블럭을 지우고나서 -*/
nx_one -= 10; /*- x 좌표에
10 감해준 후(한칸 왼쪽으로 이동) -*/
draw_block_one(1, nowbcol_one); /*- 블럭을 새
로 그려준다 -*/
}

void left_move_two()
{
if(what_around_two(1) != 0) /*- 1 left 키 -*/
return; /*- 움직일 수
없으면 아무것도 실행하지 않음 -*/
draw_block_two(0, nowbcol_two); /*- 움직일 수
있으면 현재 블럭을 지우고나서 -*/
nx_two -= 10; /*- x 좌표에
10 감해준 후(한칸 왼쪽으로 이동) -*/
draw_block_two(1, nowbcol_two); /*- 블럭을 새
로 그려준다 -*/
}

void right_move_one()
{
if(what_around_one(2) != 0) /*- 2 right 키 -*/
return; /*- 움직일 수
없으면 아무것도 실행하지 않음 -*/
draw_block_one(0, nowbcol_one); /*- 움직일 수
있으면 현재 블럭을 지우고나서 -*/
nx_one += 10; /*- x 좌표에
10 더해준 후(한칸 오른쪽으로 이동) -*/
draw_block_one(1, nowbcol_one); /*- 블럭을 새
로 그려준다 -*/
}

void right_move_two()
{
if(what_around_two(2) != 0) /*- 2 right 키 -*/
return; /*- 움직일 수
없으면 아무것도 실행하지 않음 -*/
draw_block_two(0, nowbcol_two); /*- 움직일 수
있으면 현재 블럭을 지우고나서 -*/
nx_two += 10; /*- x 좌표에
10 더해준 후(한칸 오른쪽으로 이동) -*/
draw_block_two(1, nowbcol_two); /*- 블럭을 새
로 그려준다 -*/
}

void rotate_move_one()
{
if(what_around_one(3) == 0) /*-
3 left 키 */
{
draw_block_one(0, nowbcol_one);
/*- 움직일 수 있으면 현재 블럭을 지우고나
서 -*/
nowrot_one = (nowrot_one + 7) % 28;
/*- 다음번의 블럭회전형태 저장 -*/
draw_block_one(1, nowbcol_one);
/*- 블럭을 새로 그려준다 -*/
}
return;
}

void rotate_move_two()
{
if(what_around_two(3) == 0) /*-
3 left 키 */
{
draw_block_two(0, nowbcol_one);
/*- 움직일 수 있으면 현재 블럭을 지우고나
서 -*/
nowrot_two = (nowrot_two + 7) % 28;
/*- 다음번의 블럭회전형태 저장 -*/
draw_block_two(1, nowbcol_two);
/*- 블럭을 새로 그려준다 -*/
}
return;
}

gint what_around_one(gint x) /*- 배경을 저장한 배열에서 블럭이 움직
일 곳을 검사 -*/
{ /*- 검사값(리
턴값)이 0(검정색)이면 움직일 수 있음 -*/
gint i, c, re = 0;

/*- block_x[nowbrick+nowrot_one][i]+nx_one 블럭의 현재위
치 x 좌표 -*/
/*- block_y[nowbrick+nowrot_one][i]+ny_one 블럭의 현재위
치 y 좌표 -*/
switch(x)
{
case 0
for(i = 0; i < 4; i++)
/*- down인 경우 한칸 아래 검사 -*/
if((c = bk_gnd1[(block_x
[nowbl_one+nowrot_one][i]+tx+nx_one)/10]
[(block_y
[nowbl_one+nowrot_one][i]+ty+ny_one)/10 + 1]) > 0) re = c;
break;

case 1
for(i = 0; i < 4; i++)
/*- left인 경우 한칸 왼쪽 검사 -*/
if((c = bk_gnd1[(block_x
[nowbl_one+nowrot_one][i]+tx+nx_one)/10 - 1]
[(block_y
[nowbl_one+nowrot_one][i]+ty+ny_one)/10]) > 0) re = c;
break;

case 2
for(i = 0; i < 4; i++)
/*- right인 경우 한칸 오른쪽 검사 -*/
if((c = bk_gnd1[(block_x
[nowbl_one+nowrot_one][i]+tx+nx_one)/10 + 1]
[(block_y
[nowbl_one+nowrot_one][i]+ty+ny_one)/10]) > 0) re = c;
break;

case 3
for(i = 0; i < 4; i++)
/*- rotate인 경우 회전 후 좌표 검사 -*/
if((c = bk_gnd1[(block_x[nowbl_one+
((nowrot_one+7)%28)][i]+tx+nx_one)/10]
[(block_y[nowbl_one+
((nowrot_one+7)%28)][i]+ty+ny_one)/10]) > 0) re = c;
break;

case 4
for(i = 0; i < 4; i++)
/*- 현재 위치 검사(종료여부 판별) -*/
if((c = bk_gnd1[(block_x
[nowbl_one+nowrot_one][i]+tx+nx_one)/10]
[(block_y
[nowbl_one+nowrot_one][i]+ty+ny_one)/10]) > 0) re = c;
break;
}
return re; /*- 리턴값이 0이면 움직임이 가능함을 뜻함 -*/
}

gint what_around_two(gint x) /*- 배경을 저장한 배열에서 블럭이 움직
일 곳을 검사 -*/
{ /*- 검사값(리
턴값)이 0(검정색)이면 움직일 수 있음 -*/
gint i, c, re = 0;

/*- block_x[nowbrick+nowrot_one][i]+nx_one 블럭의 현재위
치 x 좌표 -*/
/*- block_y[nowbrick+nowrot_one][i]+ny_one 블럭의 현재위
치 y 좌표 -*/
switch(x)
{
case 0
for(i = 0; i < 4; i++)
/*- down인 경우 한칸 아래 검사 -*/
if((c = bk_gnd2[(block_x
[nowbl_two+nowrot_two][i]+tx+nx_two)/10]
[(block_y
[nowbl_two+nowrot_two][i]+ty+ny_two)/10 + 1]) > 0) re = c;
break;

case 1
for(i = 0; i < 4; i++)
/*- left인 경우 한칸 왼쪽 검사 -*/
if((c = bk_gnd2[(block_x
[nowbl_two+nowrot_two][i]+tx+nx_two)/10 - 1]
[(block_y
[nowbl_two+nowrot_two][i]+ty+ny_two)/10]) > 0) re = c;
break;

case 2
for(i = 0; i < 4; i++)
/*- right인 경우 한칸 오른쪽 검사 -*/
if((c = bk_gnd2[(block_x
[nowbl_two+nowrot_two][i]+tx+nx_two)/10 + 1]
[(block_y
[nowbl_two+nowrot_two][i]+ty+ny_two)/10]) > 0) re = c;
break;

case 3
for(i = 0; i < 4; i++)
/*- rotate인 경우 회전 후 좌표 검사 -*/
if((c = bk_gnd2[(block_x[nowbl_two+
((nowrot_two+7)%28)][i]+tx+nx_two)/10]
[(block_y[nowbl_two+
((nowrot_two+7)%28)][i]+ty+ny_two)/10]) > 0) re = c;
break;

case 4
for(i = 0; i < 4; i++)
/*- 현재 위치 검사(종료여부 판별) -*/
if((c = bk_gnd2[(block_x
[nowbl_two+nowrot_two][i]+tx+nx_two)/10]
[(block_y
[nowbl_two+nowrot_two][i]+ty+ny_two)/10]) > 0) re = c;
break;
}
return re; /*- 리턴값이 0이면 움직임이 가능함을 뜻함 -*/
}

void is_full_one() /*- 가로줄의 완성 여부와 그에 따른 처리 -*/
{
gint check1, check2, i, j, k;

res_bg_one();

if(oneflag == 0)
{
score_one += 2;
print_score(score_one, 1);
}

check2 = 0;

for(i = 19 ; i >= 0; i--)
{
check1 = 0;

for(j = 1 ; j <= 13 ; j++)
{
if(bk_gnd1[j][i] == 0)
check1 = 1; /*- 가로줄상에 검정
색이 있으면 -*/
}

if(check1 == 0) /*- 검정색이 없는경우(블럭으로
꽉 찬 경우) -*/
{
score_one += 10;

check2 =1;

for(k = i-1 ; k > 0 ; k--)
for(j = 1 ; j <= 13 ; j++)
{
bk_gnd1[j][k+1] =
bk_gnd1[j][k];
}
i++;
}

}

print_score(score_one, 1);

if(check2 == 0) return;

for(i = 1; i <= 19; i++)
for(j = 1; j <=13; j++)
{
gdk_colormap_alloc_color(col_mp, &color
[bk_gnd1[j][i]], FALSE, TRUE);
gdk_gc_set_foreground(tet_bl, &color
[bk_gnd1[j][i]]);
gdk_draw_rectangle(pix_m1, tet_bl,
TRUE, j*10, i*10, 9, 9);
}

gtk_object_set_data(GTK_OBJECT(wor_a1), "pixmap", pix_m1);
gdk_draw_pixmap(wor_a1->window, tet_bl, pix_m1, 0, 0, 0,
0, 150, 220);
}

void is_full_two() /*- 가로줄의 완성 여부와 그에 따른 처리 -*/
{
gint check1, check2, i, j, k;

res_bg_two();

if(twoflag == 0)
{
score_two += 2;
print_score(score_two, 2);
}

check2 = 0;

for(i = 19 ; i >= 0; i--)
{
check1 = 0;

for(j = 1 ; j <= 13 ; j++)
{
if(bk_gnd2[j][i] == 0)
check1 = 1; /*- 가로줄상에 검정
색이 있으면 -*/
}

if(check1 == 0) /*- 검정색이 없는경우(블럭으로
꽉 찬 경우) -*/
{
score_two += 10;

check2 =1;

for(k = i-1 ; k > 0 ; k--)
for(j = 1 ; j <= 13 ; j++)
{
bk_gnd2[j][k+1] =
bk_gnd2[j][k];
}
i++;
}

}

print_score(score_two, 2);

if(check2 == 0) return;

for(i = 1; i <= 19; i++)
for(j = 1; j <=13; j++)
{
gdk_colormap_alloc_color(col_mp, &color
[bk_gnd2[j][i]], FALSE, TRUE);
gdk_gc_set_foreground(tet_br, &color
[bk_gnd2[j][i]]);
gdk_draw_rectangle(pix_m2, tet_br,
TRUE, j*10, i*10, 9, 9);
}

gtk_object_set_data(GTK_OBJECT(wor_a2), "pixmap", pix_m2);
gdk_draw_pixmap(wor_a2->window, tet_br, pix_m2, 0, 0, 0,
0, 150, 220);
}

//void score_left() /*- 점수 출력 -*/
//{
// gdk_draw_string(pix_m1, wor_a1->style->font, tet_bl, 10,
215, );
//}

void restore_bg() /*- 배경배열 초기화 -*/
{
gint i, j;
for(i = 0; i < 15; i++)
for(j = 0; j < 21; j++)
{
if(i == 0 || i == 14 || j == 20)
bk_gnd1[i][j] = 5;
else
bk_gnd1[i][j] = 0;
}

if(tetflag == 1)
{
for(i = 0; i < 15; i++)
for(j = 0; j < 21; j++)
{
if(i == 0 || i == 14 || j == 20)
bk_gnd2[i][j] = 6;
else
bk_gnd2[i][j] = 0;
}
}
}

void res_bg_one() /*- 배경배열 갱신 -*/
{
gint i;
for(i = 0; i < 4; i++)
{
bk_gnd1[(block_x[nowbl_one+nowrot_one][i]
+tx+nx_one)/10]
[(block_y[nowbl_one+nowrot_one][i]
+ty+ny_one)/10] = nowbcol_one;
}
}

void res_bg_two() /*- 배경배열 갱신 -*/
{
gint i;
for(i = 0; i < 4; i++)
{
bk_gnd2[(block_x[nowbl_two+nowrot_two][i]
+tx+nx_two)/10]
[(block_y[nowbl_two+nowrot_two][i]
+ty+ny_two)/10] = nowbcol_two;
}
}

void print_score(gint sco, gint who)
{
char tmpsco[10];
gint i = 0, c, j;

do{
tmpsco[i++] = sco % 10 + '0';
}while((sco /= 10) > 0);

tmpsco[i] = '\0';

for(i = 0, j = strlen(tmpsco) - 1; i < j; i++, j--)
{
c = tmpsco[i];
tmpsco[i] = tmpsco[j];
tmpsco[j] = c;
}

if(who == 1)
{
gdk_colormap_alloc_color(col_mp, &wor_a1->style-
>bg[GTK_STATE_NORMAL], FALSE, TRUE);
gdk_gc_set_foreground(tet_bl , &wor_a1->style->bg
[GTK_STATE_NORMAL]);
gdk_draw_rectangle(pix_m1, tet_bl, TRUE, 40, 208,
50, 12);

gdk_colormap_alloc_color(col_mp, &color[0],
FALSE, TRUE);
gdk_gc_set_foreground(tet_bl, &color[0]);
gdk_draw_string(pix_m1, wor_a1->style->font,
tet_bl, 50, 217, tmpsco);

gdk_draw_pixmap(wor_a1->window, tet_bl, pix_m1,
0, 0, 0, 0, 150, 220);
}

if(who == 2)
{
gdk_colormap_alloc_color(col_mp, &wor_a1->style-
>bg[GTK_STATE_NORMAL], FALSE, TRUE);
gdk_gc_set_foreground(tet_br , &wor_a2->style->bg
[GTK_STATE_NORMAL]);
gdk_draw_rectangle(pix_m2, tet_br, TRUE, 40, 208,
50, 12);

gdk_colormap_alloc_color(col_mp, &color[0],
FALSE, TRUE);
gdk_gc_set_foreground(tet_br, &color[0]);
gdk_draw_string(pix_m2, wor_a2->style->font,
tet_br, 50, 217, tmpsco);

gdk_draw_pixmap(wor_a2->window, tet_br, pix_m2,
0, 0, 0, 0, 150, 220);
}
}