贪吃蛇

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <time.h>
#include <signal.h>

#define WIDTH 10
#define HEIGHT 10
#define SUCCESS 0
#define FAILURE 1
#define EATEN_FOOD 2
#define GAME_OVER 3

const int width = WIDTH;
const int height = HEIGHT;
static int area[WIDTH][HEIGHT];

#define CHECK_FALSE_RET(expr, ret) if(!(expr)) return ret;

#define LOG(format, ...) //printf(format, ##__VA_ARGS__)

typedef enum Direct {
    NO_DIRECT,
    UP,
    DOWN,
    LEFT,
    RIGHT
}Direct;

typedef struct Point {
    int x;
    int y;
    Point *next;
}Point;

typedef struct Snake {
    Point *head;
    Point *tail;
    int length;
    Direct direct;
}Snake;

Point* NewPoint()
{
    Point *np = (Point*)malloc(sizeof(Point));
    if(np != NULL)
    {
        memset(np, 0, sizeof(Point));
    }
    return np;
}

Point* NewPointWithParam(int x, int y)
{
    Point *np = NewPoint();
    if(np != NULL)
    {
        np->x = x;
        np->y = y;
    }
    return np;
}

Direct DecideForwardDirect(Snake *snake, Point *food)
{
    if(snake == NULL || food == NULL)
    {
        LOG("[error]: DecideForwardDirect failed. snake=NULL|food=NULL
");
         return NO_DIRECT;
    }
    Direct dir = NO_DIRECT;
    Point *head = snake->head;
    if(head == NULL) 
    {
        LOG("[error]: DecideForwardDirect failed. head=NULL
");
        return NO_DIRECT;
    }
    
    switch(snake->direct)
    {
        case UP:
            if(head->x == 0) dir = RIGHT;
            else if(head->x == width-2) dir = LEFT;
            break;
        case DOWN:
            if(head->x == width - 1)
            {
                if(head->y == height - 1) dir = LEFT;
                else dir = DOWN;
            }
            break;
        case LEFT:
            if(head->x == 0) dir = UP;
            else dir = LEFT;
            break;
        case RIGHT:
            if(head->y == 0 && head->x == width - 1) dir = DOWN;
            else if(head->y != 0 && head->x == width - 2) dir = UP;
            else dir = RIGHT;
            break;
        default:
            break;
    }
    snake->direct = dir;
    return dir;
}

Point *CreateOneFood(Snake *snake)
{    
    if(snake == NULL) return NULL;
 
    Point *np = NULL;
    Point *food = NULL;
    int unusedNum = width*height - snake->length;
    int randPos;
    int x, y;
    int foodX = -1, foodY = -1;
    memset(area, 0, width*height*sizeof(int));
    np = snake->head;
    while(np != NULL)
    {
        area[np->x][np->y] = 1;
        np = np->next;
    }
    randPos = rand() % unusedNum;
    for(x=0; x<width; x++)
    {
        if(randPos < 0) break;
        for(y=0; y<height; y++)
        {
            if(area[x][y] == 0) randPos--;
            if(randPos < 0)
            {
                foodX = x;
                foodY = y;
                break;
            }
        }
    }

    if((foodX >= 0 && foodX < width) && (foodY >= 0 && foodY < height))
    {
        food = NewPointWithParam(foodX, foodY);
    }
    
    return food;
}

int FortainEatFood(Snake *snake, Point *food)
{
    if(snake == NULL || food == NULL) return FAILURE;
    food->next = snake->head;
    snake->head = food;
    if(snake->tail == NULL) snake->tail = food;
    snake->length++;
    return SUCCESS;
}

Point *GetPreviousTail(Snake *snake)
{
    if(snake == NULL) return NULL;
    Point *np = snake->head;
     while(np->next != snake->tail && np->next != NULL) np = np->next;
    if(np->next == NULL) return NULL;
    return np;
}


int FortainForward(Snake *snake, Direct dir, Point *food)
{
    if(snake == NULL) return FAILURE;
    if(dir == NO_DIRECT) return FAILURE;
    if(food == NULL) return FAILURE;
    Point *preTail;
    preTail = GetPreviousTail(snake);
    if(preTail == NULL) return FAILURE;
    int currX = snake->head->x;
    int currY = snake->head->y;
    int nextX = currX;
    int nextY = currY;
    
    switch(dir)
    {
        case UP:
            nextY = currY - 1;
            break;
        case DOWN:
            nextY = currY + 1;
            break;
        case LEFT:
            nextX = currX - 1;
            break;
        case RIGHT:
            nextX = currX + 1;
        default:
            break;
    }
    if(nextX == food->x && nextY == food->y)
    {
        FortainEatFood(snake, food);
        return EATEN_FOOD;
    }
    else
    {
        snake->tail->x = nextX;
        snake->tail->y = nextY;
        snake->tail->next = snake->head;
        snake->head = snake->tail;
        snake->tail = preTail;
        snake->tail->next = NULL;
    }
    
    return SUCCESS;
}

int FortainGameInit(Snake *snake)
{
    if(snake == NULL) return FAILURE;
    Point *np1 = NewPointWithParam(width-1, height-1);
    Point *np2 = NewPointWithParam(width-2, height-1);
    Point *np3 = NewPointWithParam(width-3, height-1);
    if(np1 == NULL || np2 == NULL || np3 == NULL) return FAILURE;
    
    FortainEatFood(snake, np1);
    FortainEatFood(snake, np2);
    FortainEatFood(snake, np3);

    snake->direct = LEFT;
    return SUCCESS;
}

int FortainGameCheck(Snake *snake)
{
    if(snake == NULL) return FAILURE;
    memset(area, 0, width*height*sizeof(int));
    Point *np = snake->head;
    while(np != NULL)
    {
        CHECK_FALSE_RET(np->x >= 0, FAILURE);
        CHECK_FALSE_RET(np->x < width, FAILURE);
        CHECK_FALSE_RET(np->y >= 0, FAILURE);
        CHECK_FALSE_RET(np->y < height, FAILURE);

        CHECK_FALSE_RET(area[np->x][np->y] == 0, GAME_OVER);
        area[np->x][np->y] = 1;
        np = np->next;
    }
    CHECK_FALSE_RET(snake->length != width*height, GAME_OVER);
    return SUCCESS;
}

void FortainGameMain()
{
    Snake snake;
    Point *food;
    int ret;
    int count = 0;
    Direct dir;

    memset(&snake, 0, sizeof(Snake));
    ret = FortainGameInit(&snake);
    if(ret == FAILURE) 
    {
        LOG("[error]: GameInit failed!
");
        return;
    }
    LOG("[info]: GameInit done! length=%d
", snake.length);
    
    Point *np = snake.head;
    while(np != NULL)
    {
        LOG("x=%d,y=%d,next=%x
", np->x, np->y, np->next);
        np = np->next;
    }
    
    food = CreateOneFood(&snake);
    if(food == NULL) LOG("[error]: CreateFood failed!
");
    else LOG("[info]: CreateFood success! P(%d, %d)
", food->x, food->y);
    while(true)
    {
        dir = DecideForwardDirect(&snake, food);
        LOG("[info]: DecideDirect, dir=%d
", dir);
        ret = FortainForward(&snake, dir, food);
        LOG("[info]: Forward, dir=%d, food=(%d,%d), head=(%d,%d), length=%d
", dir, food->x, food->y, snake.head->x, snake.head->y, snake.length);
        if(ret == FAILURE)
        {
            LOG("[error]: Forward failed.dir|%d,length|%d.
", dir, snake.length);
            break;
        }
        else if(ret == EATEN_FOOD)
        {
            LOG("[info]: Eat food. length|%d
", snake.length);
            if(snake.length < width*height)
            {
                food = CreateOneFood(&snake);
                if(food == NULL)
                {
                    LOG("[error]: CreateFood failed!
");
                    break;
                }
                else LOG("[info]: CreateFood success! P(%d, %d)
", food->x, food->y);
            }
        }
        ret = FortainGameCheck(&snake);
        if(ret == FAILURE)
        {
            LOG("[error]: GameCheck failed!
");
            break;
        }
        else if(ret == GAME_OVER)
        {
            printf("[info]: Game over!!! length=%d, count=%d
", snake.length, count);
            break;
        }
        count++;
    }
}

void SignHandler(int sign)
{
    switch(sign)
    {
        case SIGABRT:
            printf("signal: SIGABRT. 
 程序异常终止。
");
            break;
        case SIGFPE:
            printf("signal: SIGFPE. 
 算术运算出错，如除数为 0 或溢出（不一定是浮点运算）。
");
            break;
        case SIGILL:
            printf("signal: SIGILL. 
 非法函数映象，如非法指令，通常是由于代码中的某个变体或者尝试执行数据导致的。
");
            break;
        case SIGINT:
            printf("signal: SIGINT. 
 中断信号，如 ctrl-C，通常由用户生成。
");
            break;
        case SIGSEGV:
            printf("signal: SIGSEGV. 
 非法访问存储器，如访问不存在的内存单元。
");
            break;
        case SIGTERM:
            printf("signal: SIGTERM. 
 发送给本程序的终止请求信号。
");
            break;
    }
}

int main()
{
    signal(SIGABRT, SignHandler);
    signal(SIGFPE, SignHandler);
    signal(SIGILL, SignHandler);
    signal(SIGINT, SignHandler);
    signal(SIGSEGV, SignHandler);
    signal(SIGTERM, SignHandler);
    for(int i=0; i<100; i++)
    {
        clock_t start = clock();
        srand(time(NULL));
        FortainGameMain();
        printf("Time: %d ms
", clock()-start);
    }
    return 0;
}