贪吃蛇

写个贪吃蛇的Demo，只有蛇

#include <stdio.h>
#include <time.h>
#include <string.h>
#include <signal.h>
#include <stdlib.h>
#include <assert.h>

#define bool int
#define true 1
#define false 0 

#define MAXLEN 50

struct SNACK_NODE{
	int x,y;
	int direction;//0up,1right,2down,3left
	struct SNACK_NODE * next;
};

struct SNACK_QUEUE{
	struct SNACK_NODE *head,*tail;
};

struct SNACK_QUEUE *SnackQueueCreate(){
    struct SNACK_QUEUE *obj = malloc(sizeof(struct SNACK_QUEUE));
    obj->head = NULL;
    obj->tail = NULL;
    return obj;
}

void SnackQueuePush(struct SNACK_QUEUE * obj,struct SNACK_NODE *snack_node){
    if(obj->tail == NULL){
        obj->head = snack_node;
        obj->tail = snack_node;
    }else{
        obj->tail->next = snack_node;
        obj->tail = snack_node;
    }
}

void SnackQueuePop(struct SNACK_QUEUE * obj){
    if(obj->head == NULL)
        return;
    struct SNACK_NODE* node = obj->head;
    if(obj->head == obj->tail){
        obj->head = NULL;
        obj->tail = NULL;
    }else{
        obj->head = node->next;
    }
    free(node);
}

struct SNACK_NODE* SnackQueuePeek(struct SNACK_QUEUE *obj){
    if(obj->head == NULL)
        return NULL;
    struct SNACK_NODE *node = obj->head;
	/*
    if(obj->head == obj->tail){
        obj->head = NULL;
        obj->tail = NULL;
    }else{
        obj->head = node->next;
    }

    return node;
	*/
	return obj->head;
}

bool SnackQueueEmpty(struct SNACK_QUEUE *obj){
    if(obj->head == NULL)
        return true;
    return false;
}

void SnackQueueFree(struct SNACK_QUEUE* obj) {
    while(!SnackQueueEmpty(obj)){
        SnackQueuePop(obj);
    }
}

struct SNACK{
	int now_direction;//0up,1right,2down,3left
	int head_x,head_y;
	int tail_x,tail_y;
	struct SNACK_QUEUE *snack_queue;
	char n[MAXLEN][MAXLEN];//显示的时候就是打印这个数组
};

struct SNACK * SnackInit(){
	struct SNACK *snack = malloc(sizeof(struct SNACK));
	snack->now_direction = 0;//up
	snack->snack_queue = SnackQueueCreate();
	memset(snack->n,' ',sizeof(snack->n));//显示数组,全部初始化为空格

	//初始化蛇的身体
	snack->head_x = MAXLEN/2 - 6;
	snack->head_y = MAXLEN/2;

	snack->tail_x = MAXLEN/2 + 6;
	snack->tail_y = MAXLEN/2;
	snack->n[snack->head_x][snack->head_y] = '.';
	snack->n[snack->head_x+1][snack->head_y] = '.';
	snack->n[snack->head_x+2][snack->head_y] = '.';
	snack->n[snack->head_x+3][snack->head_y] = '.';
	snack->n[snack->head_x+4][snack->head_y] = '.';
	snack->n[snack->head_x+5][snack->head_y] = '.';
	snack->n[snack->head_x+6][snack->head_y] = '.';
	snack->n[snack->head_x+7][snack->head_y] = '.';
	snack->n[snack->head_x+8][snack->head_y] = '.';
	snack->n[snack->head_x+9][snack->head_y] = '.';
	snack->n[snack->head_x+10][snack->head_y] = '.';
	snack->n[snack->head_x+11][snack->head_y] = '.';
	snack->n[snack->head_x+12][snack->head_y] = '.';

	return snack;
}

void SnackRound(struct SNACK *snack,int direction){
	if(direction<0 || direction > 3)	return;

	if(direction == snack->now_direction)	return;
	if(abs(direction - snack->now_direction) == 2)	return;//反向
	struct SNACK_NODE *snack_node = malloc(sizeof(struct SNACK_NODE));
	snack_node->x = snack->head_x;
	snack_node->y = snack->head_y;
	snack_node->direction = snack->now_direction;
	snack_node->next = NULL;

	SnackQueuePush(snack->snack_queue,snack_node);
	snack->now_direction = direction;

	return;
}

void SnackWake(struct SNACK *snack){
	switch(snack->now_direction){
		case 0://up
		{
			snack->head_x--;
			break;
		}
		case 1://right
		{
			snack->head_y++;
			break;
		}
		case 2://down
		{
			snack->head_x++;
			break;
		}
		case 3://left
		{
			snack->head_y--;
			break;
		}
	}
	//越界
	assert(snack->head_x>=0);
	assert(snack->head_x<MAXLEN);
	assert(snack->head_y>=0);
	assert(snack->head_y<MAXLEN);
	/*
	if(snack->head_x <0 || snack->head_x >= MAXLEN || snack->head_y<0 || snack->head_y >= MAXLEN)
	{
		printf("GAMEOVER\n");
		return ;
	}
	*/
	//碰到自己身体
	assert(snack->n[snack->head_x][snack->head_y] != '.');
	snack->n[snack->head_x][snack->head_y] = '.';

	snack->n[snack->tail_x][snack->tail_y] = ' ';
	struct SNACK_NODE* snack_node = SnackQueuePeek(snack->snack_queue);
	if(snack_node == NULL)
	{
		switch(snack->now_direction){
			case 0://up
			{
				snack->tail_x--;
				break;
			}
			case 1://right
			{
				snack->tail_y++;
				break;
			}
			case 2://down
			{
				snack->tail_x++;
				break;
			}
			case 3://left
			{
				snack->tail_y--;
				break;
			}
		}
	}
	else{
		switch(snack_node->direction){
			case 0://up
			{
				snack->tail_x--;
				break;
			}
			case 1://right
			{
				snack->tail_y++;
				break;
			}
			case 2://down
			{
				snack->tail_x++;
				break;
			}
			case 3://left
			{
				snack->tail_y--;
				break;
			}
		}
		if(snack_node->x == snack->tail_x && snack_node->y == snack->tail_y){
			SnackQueuePop(snack->snack_queue);
		}
	}

}

struct SNACK *snack = NULL;

void sig_alarm(){
	printf("\033c");//清屏
	//system("clear");
	SnackWake(snack);

	int i,j;
	printf(" ");
	for(i=0;i<MAXLEN;i++){
		printf("-");
	}
	printf("\n");
	for(i=0;i<MAXLEN;i++){
		printf("|");
		for(j=0;j<MAXLEN;j++){
			printf("%c",snack->n[i][j]);
		}
		printf("|");
		printf("\n");
	}
	printf(" ");
	for(i=0;i<MAXLEN;i++){
		printf("-");
	}
	printf("\n");
	alarm(1);
}

int main(){
	signal(SIGALRM,sig_alarm);
	alarm(1);
	
	snack = SnackInit();//初始化蛇

	char c;
	while((c = getchar())!=EOF){//每次换方向,则调用SnackRound;alarm则调用SnackWake;Ctrl+D退出循环，释放蛇
		switch(c){
			case 'w':
			{
				SnackRound(snack,0);
				break;
			}
			case 'd':
			{
				SnackRound(snack,1);
				break;
			}
			case 's':
			{
				SnackRound(snack,2);
				break;
			}
			case 'a':
			{
				SnackRound(snack,3);
				break;
			}
			default:
			{
				//printf("wrong input %02x\n",c);
			}
		}
	}
	alarm(0);
	SnackQueueFree(snack->snack_queue);
	free(snack);
	printf("exit game\n");
}