actions.c

本程序是扫雷游戏在linux下可以运行的

#include "actions.h"


gint count_bomb (gint i, gint j)
{
	if (i < 0 || j < 0 || i >= MAX_ROW || j >= MAX_COL) {
		return 0;
	}
	//when we run out of range, simply return zero
	else {
		return bomb[i][j];
	}
}
gint count_bomb_near (gint i, gint j)
{
//i -> row , j -> col
	gint num,r,l;
	g_assert (bomb[i][j] != M_YES);
	num = 0;
	for (r = i-1; r <= i+1; r++)
		for (l = j-1; l <= j+1; l++)
			num += count_bomb (r, l);
	return num;	
}

void draw_unknow (GtkWidget* widget, gint i, gint j)
{
	/*gdk_draw_rectangle (widget->window, widget->style->white_gc,
				FALSE,
				j*BLOCK_WIDTH, i*BLOCK_HEIGHT,
				BLOCK_WIDTH, BLOCK_HEIGHT);
	*/
	GdkPixmap* unknow;
	unknow = gdk_pixmap_create_from_xpm_d (widget->window,
			NULL, NULL, (gchar**) c_xpm);
	gdk_draw_pixmap (widget->window, widget->style->black_gc,
			unknow,
			0, 0, j*BLOCK_WIDTH, i*BLOCK_HEIGHT, -1, -1);
	gdk_pixmap_unref (unknow);
}

void draw_one (GtkWidget* widget, gint i, gint j, gint num)
{
	gint count;
	char countstr[10];
	if (num == 0) {
		count = count_bomb_near (i, j);
		number[i][j] = count;
		//sorry, i really do _not_ want to add this matrix
		//i will try to clean it
		sprintf (countstr, "%d", count);
	}
	else {
		number[i][j] = num;
		sprintf (countstr, "%d", num);
	}
	draw_unknow (widget, i, j);
	gtk_draw_string (widget->style, widget->window,
			GTK_STATE_NORMAL,
			j*BLOCK_WIDTH+8, i*BLOCK_HEIGHT+12, countstr);
}

void draw_no (GtkWidget* widget, gint i, gint j)
{
	gdk_draw_rectangle (widget->window, widget->style->white_gc,
				TRUE,
				j*BLOCK_WIDTH, i*BLOCK_HEIGHT,
				BLOCK_WIDTH, BLOCK_HEIGHT);
}

void draw_mark (GtkWidget* widget, gint i, gint j)
{
	GdkPixmap* mark;
	mark = gdk_pixmap_create_from_xpm_d (widget->window,
				NULL, NULL, (gchar**) f_xpm);
	gdk_draw_pixmap (widget->window, widget->style->black_gc,
			mark,
			0, 0, j*BLOCK_WIDTH, i*BLOCK_HEIGHT,
				-1, -1);
	gdk_pixmap_unref (mark);
}
void draw_discover (GtkWidget* widget, gint i, gint j)
{
	GdkPixmap* discover;
	discover = gdk_pixmap_create_from_xpm_d (widget->window,
				NULL, NULL, (gchar**) i_xpm);
	gdk_draw_pixmap (widget->window, widget->style->black_gc,
			discover,
			0, 0, j*BLOCK_WIDTH, i*BLOCK_HEIGHT,
				-1, -1);
}
void draw_bomb (GtkWidget* widget, gint i, gint j)
{
	GdkPixmap* bomb;
	/*gdk_draw_rectangle (widget->window, widget->style->white_gc,
				TRUE,
			j*BLOCK_WIDTH, i*BLOCK_HEIGHT,
			BLOCK_WIDTH, BLOCK_HEIGHT);
	*/
	bomb = gdk_pixmap_create_from_xpm_d (widget->window,
				NULL, NULL, (gchar**) e_xpm);
	gdk_draw_pixmap (widget->window, widget->style->white_gc,
			bomb,
			0, 0, j*BLOCK_WIDTH, i*BLOCK_HEIGHT,
				-1, -1);
	gdk_pixmap_unref (bomb);
}

void area_expose (GtkWidget* widget, GdkEvent* event)
{
	gint i, j;

	for (i=0; i<MAX_ROW; i++)
		for (j=0; j<MAX_COL; j++) {
			switch (block[i][j]) {
				case B_UNKNOW:
					if (LOST == 0 || bomb[i][j] != M_YES)
						draw_unknow (widget, i, j);
					else
						draw_bomb (widget, i, j);
					break;
				case B_ONE:
					draw_one (widget, i, j, 0);
					break;
				case B_NO:
					draw_no (widget, i, j);
					break;
				case B_MARK:
					if (LOST == 0) 
						draw_mark (widget, i, j);
					else if (bomb[i][j] == M_YES)
						draw_discover (widget, i, j);
					else
						draw_unknow (widget, i, j);
					break;
				case B_BOMB://not use
					break;
				break;
			}
		}
}	



void lost_game (GtkWidget* widget, gint i, gint j)
{
	char lab[]="Sorry, You Lost!";
	START = 0;
	LOST = 1;
	gtk_label_set_text (GTK_LABEL(label), lab);
	gtk_drawing_area_size (GTK_DRAWING_AREA(area), 
				MAX_COL*BLOCK_WIDTH, MAX_ROW*BLOCK_HEIGHT);
	
	//log_name (timer); //for test

}

void expand_zero (GtkWidget* widget, gint i, gint j)
{
	gint r, l, num;

	if (i < 0 || j < 0 || i >= MAX_ROW || j>= MAX_COL)
		return;
	if (block[i][j] != B_UNKNOW)
		return;
	num = count_bomb_near (i, j);
	if (num > 0) {
		block[i][j] = B_ONE;
		draw_one (widget, i, j, num);
		return;
	}

	block[i][j] = B_NO;
	draw_no (widget, i, j);
	for (r = i-1; r <= i+1; r++)
		for (l = j-1; l <=j+1; l++) {
			expand_zero (widget, r, l);
		}			
}

void dig_bomb (GtkWidget* widget, gint i, gint j)
{
//i -> row , j -> col
	gint num;
	g_assert (block[i][j] == B_UNKNOW);
	if (bomb[i][j] == M_YES) {
		myout ("find a bomb\n");
		lost_game(widget, i, j);
		return;
	}
	num = count_bomb_near (i, j);
	if (num > 0) {
		myout ("find a block with bomb near\n");
		block[i][j] = B_ONE;
		draw_one (widget, i, j, num);
	}
	else {
		myout ("find a block without bomb near\n");
		expand_zero (widget, i, j);
	}
}

void mark_bomb(GtkWidget* widget, gint i, gint j)
{
	char lab[20];
	if (BOMBNUM == 0)
		return;
	block[i][j] = B_MARK;
	BOMBNUM--;
	draw_mark(widget, i, j);
	if (bomb[i][j] == M_YES) {
		REALNUM--;
	}
	if (REALNUM == 0){
		sprintf (lab, "Congratulations!");
		START = 0;
		LOST = 0;
		//fprintf (stderr, "really lost=%d\n", LOST);
		log_name (timer);
	}
	else {
		sprintf (lab, "%d bombs left", BOMBNUM);
	}
	gtk_label_set_text (GTK_LABEL(label), lab);
}

void draw_unmark (GtkWidget* widget, gint i, gint j)
{
	/*gdk_draw_rectangle (widget->window, widget->style->bg_gc[0],
				TRUE,
				j*BLOCK_WIDTH+1, i*BLOCK_HEIGHT+1,
				BLOCK_WIDTH-2, BLOCK_HEIGHT-2);
	*/
	draw_unknow (widget, i, j);
}

void unmark_bomb (GtkWidget* widget, gint i, gint j)
{
	char lab[20];
	BOMBNUM++;
	if (bomb[i][j] == M_YES)
		REALNUM++;
	sprintf (lab, "%d bombs left", BOMBNUM);
	gtk_label_set_text (GTK_LABEL(label), lab);
	block[i][j] = B_UNKNOW;
	draw_unmark(widget, i, j);
}

gint button_press (GtkWidget* widget, GdkEventButton *event, gpointer data)
{
	gint i, j;
	GtkWidget* area = GTK_WIDGET(data);
	
	if (!START)
		return FALSE;

	i = event->x / BLOCK_WIDTH;
	j = event->y / BLOCK_HEIGHT;
	
	if (i < 0 || j < 0 || i >= MAX_COL || j >= MAX_ROW)
		return FALSE;

#ifdef _DEBUG
	fprintf (stderr, "i=%d j=%d\n", i, j);
#endif
	if (event->button == 1) {
		myout ("left button\n");
		if (block[j][i] == B_UNKNOW) {
			dig_bomb(area, j, i);
		}
	}
	else if (event->button == 3){
		myout ("right button\n");
		if (block[j][i] == B_UNKNOW) {
			mark_bomb(area, j, i);
		}
		else if (block[j][i] == B_MARK) {
			unmark_bomb(area, j, i);
		}
	}		
	return FALSE;
}

void load_bomb()
{
	gint r, b[2], num=0;
	do {
        	do {
	
        	        r = rand();
        	        r = (gint)((gfloat)MAX_COL*(gfloat)MAX_ROW
        	                *(gfloat)r/(gfloat)(RAND_MAX));
        	        b[0] = r/MAX_COL;
        	        b[1] = r%MAX_COL;
        	        g_assert (b[0] < MAX_ROW);
        	        g_assert (b[1] < MAX_COL);
        	}
        	while (bomb[b[0]][b[1]] == M_YES);
		bomb[b[0]][b[1]] = M_YES;
		num++;
	}
	while (num < MAX_BOMB); 
}

void clear_area ()
{
	//clear old
	int i;
	if (block != NULL) {
		g_free (block[0]);
		g_free (block);
	}
	if (bomb != NULL) {
		g_free (bomb[0]);
		g_free (bomb);
	}
	if (number != NULL) {
		g_free (number[0]);
		g_free (number);
	}
}

void reset_area ()
{
	int i;
	char lab[20];
//x ->row, y ->col
	//create new
	block = (gint**)g_malloc(MAX_ROW*sizeof(gint*));
	bomb = (gint**)g_malloc(MAX_ROW*sizeof(gint*));