C语言版贪吃蛇控制台Linux游戏NCurse

最新推荐文章于 2023-11-12 19:39:02 发布
最新推荐文章于 2023-11-12 19:39:02 发布
阅读量277 收藏 2
点赞数
分类专栏： C语言 文章标签： C语言 Ncurses 贪吃蛇 多线程 游戏开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_Xian/article/details/112321727
版权

文章目录

项目的目的

熟练掌握C语言，并非要精通Ncurse

Ncurse的输入输出

#include <curses.h>

int main(){
    initscr();//ncurse界面的初始化
    printw("hello world\n");//这是ncurse模式下的printf
    getch();//等待用户输入，如果没有这句话，程序就退出了，看不到运行的结果，也就是看不到上面那句话
    endwin();//程序退出，调用该函数来回复shell终端的显示，如果没有这句话，shell终端字乱码，坏掉。
    return 0;
}

编译指令

vi cursedemo.c
gcc cursedemo.c -lcurses
./a.out

要改名的话

gcc cursedemo.c -lcurses -o cursedemo
./cursedemo

Ncurse上下左右键获取

#include <curses.h>

int main(){
    int key;//因为用char表示的话是1字节8位最大值是128，小于curses.h中定义的方向值
    initscr();
    keypad(stdscr,1);//想要获取方向键必须写的函数
    while(1){
        key = getch();
        switch(key){
            case KEY_DOWN:
                printw("DOWN\n");
                break;
            case KEY_UP:
                printw("UP\n");
                break;
            case KEY_LEFT:
                printw("LEFT\n");
                break;
            case KEY_RIGHT:
                printw("RIGHT\n");
                break;
        }
    }
    endwin();
    return 0;
}

地图规划

大小20x20或40x40

地图竖直方向上的边界“|”

地图水平方向上的边界“–”

贪吃蛇的身子“[]”

贪吃蛇的食物“##”

地图实现

第1和最后一行画“–”，其它行首列和最后一列画“|”，其余画空格

//初始化ncurse
//画地图

#include <curses.h>

void initNcurse(){
    initscr();
    keypad(stdscr,1);
}

void gamePic(){
    int hang;
    int lie;
    
    for(hang=0;hang<20;hang++){
        if(hang == 0){
            for(lie=0;lie<20;lie++){
                printw("--");
            }
            printw("\n");
        }
        
        if(hang>=0 && hang<=19){
            for(lie=0;lie<=20;lie++){
                if(lie==0 || lie==20){
                    printw("|");
                }else{
                    printw("  ");
                }
            }
            printw("\n");
        }
        
        if(hang == 19){
            for(lie=0;lie<20;lie++){
                printw("--");
            }
            printw("\n");
            printw("By Aaron\n");
        }
    }
}

int main()
{
    initNcurse();
    gamePic();
    
    getch();
    endwin();
    return 0;
}

画蛇的身子

用链表作蛇身，当蛇身的坐标与地图上的坐标相等，画蛇身

//定义蛇身
//初始化蛇身
//添加蛇身
//画蛇身

#include <curses.h>
#include <stdlib.h>

typedef struct Snake{
    int row;
    int column;
    struct Snake *next;
}Snake;

Snake *head;
Snake *tail;

void initNcurse(){
    initscr();
    keypad(stdscr,1);
}

int hasSnakeNode(int row,int column){
    Snake *p = head;
    while(p != NULL){
        if(p->row == row && p->column == column){
            return 1;
        }
        p = p->next;
    }
    return 0;
}

void gamePic(){
    int row;
    int column;
    
    for(row=0;row<20;row++){
        if(row == 0 || row == 19){
            for(column=0;column<20;column++){
                printw("--");
            }
            printw("\n");
        }
        
        if(row>0 && row<19){
            for(column=0;column<=20;column++){
                if(column==0 || column==20){
                    printw("|");
                }else if(hasSnakeNode(row,column)){
                    printw("[]");
                }else{
                    printw("  ");
                }
            }
            printw("\n");
        }
    }
}

void addNode(){
    Snake *newNode = (Snake *)malloc(sizeof(Snake));
    newNode->row = tail->row;
    newNode->column = tail->column + 1;
    newNode->next = NULL;
    
    tail->next = newNode;
    tail = newNode;
}

void initSnake(){
    head = (Snake *)malloc(sizeof(Snake));
    head->row = 2;
    head->column = 2;
    head->next = NULL;
    
    tail = head;
    addNode();
    addNode();
    addNode();
}

int main()
{
    initNcurse();
    initSnake();
    
    gamePic();
    
    getch();
    endwin();
    return 0;
}

让蛇向右移动

蛇向右移就是在蛇的尾部添加一个节点并删除头部节点

//判断按键如果向右
//蛇向右移动
注意在画图的方法中添加move(0,0);

#include <curses.h>
#include <stdlib.h>

typedef struct Snake{
    int row;
    int column;
    struct Snake *next;
}Snake;

Snake *head;
Snake *tail;

void initNcurse(){
    initscr();
    keypad(stdscr,1);
}

int hasSnakeNode(int row,int column){
    Snake *p = head;
    while(p != NULL){
        if(p->row == row && p->column == column){
            return 1;
        }
        p = p->next;
    }
    return 0;
}

void gamePic(){
    int row;
    int column;
    
    move(0,0);
    
    for(row=0;row<20;row++){
        if(row == 0 || row == 19){
            for(column=0;column<20;column++){
                printw("--");
            }
            printw("\n");
        }
        
        if(row>0 && row<19){
            for(column=0;column<=20;column++){
                if(column==0 || column==20){
                    printw("|");
                }else if(hasSnakeNode(row,column)){
                    printw("[]");
                }else{
                    printw("  ");
                }
            }
            printw("\n");
        }
    }
}

void addNode(){
    Snake *newNode = (Snake *)malloc(sizeof(Snake));
    newNode->row = tail->row;
    newNode->column = tail->column + 1;
    newNode->next = NULL;
    
    tail->next = newNode;
    tail = newNode;
}

void initSnake(){
    head = (Snake *)malloc(sizeof(Snake));
    head->row = 2;
    head->column = 2;
    head->next = NULL;
    
    tail = head;
    addNode();
    addNode();
    addNode();
}

void deleteNode(){
    Snake *p;
    p = head;
    head = head->next;
    free(p);
}

void moveSnake(){
    addNode();
    deleteNode();
}

int main()
{
    int control;
    initNcurse();
    initSnake();
    
    gamePic();
    
    while(1){
        control = getch();
        if(control == KEY_RIGHT){
            moveSnake();
            gamePic();
        }
    }
    
    getch();
    endwin();
    return 0;
}

蛇向右移动撞墙

如果蛇的坐标到了墙的地方就初始化蛇

#include <curses.h>
#include <stdlib.h>

typedef struct Snake{
    int row;
    int column;
    struct Snake *next;
}Snake;

Snake *head = NULL;
Snake *tail = NULL;

void initNcurse(){
    initscr();
    keypad(stdscr,1);
}

int hasSnakeNode(int row,int column){
    Snake *p = head;
    while(p != NULL){
        if(p->row == row && p->column == column){
            return 1;
        }
        p = p->next;
    }
    return 0;
}

void gamePic(){
    int row;
    int column;
    
    move(0,0);
    
    for(row=0;row<20;row++){
        if(row == 0 || row == 19){
            for(column=0;column<20;column++){
                printw("--");
            }
            printw("\n");
        }
        
        if(row>0 && row<19){
            for(column=0;column<=20;column++){
                if(column==0 || column==20){
                    printw("|");
                }else if(hasSnakeNode(row,column)){
                    printw("[]");
                }else{
                    printw("  ");
                }
            }
            printw("\n");
        }
    }
}

void addNode(){
    Snake *newNode = (Snake *)malloc(sizeof(Snake));
    newNode->row = tail->row;
    newNode->column = tail->column + 1;
    newNode->next = NULL;
    
    tail->next = newNode;
    tail = newNode;
}

void initSnake(){
    Snake *p = NULL;
    while(head != NULL){
        p = head;
        head = head->next;
        free(p);
    }
    
    head = (Snake *)malloc(sizeof(Snake));
    head->row = 2;
    head->column = 2;
    head->next = NULL;
    
    tail = head;
    addNode();
    addNode();
    addNode();
}

void deleteNode(){
    Snake *node = head;
    head = head->next;
    free(node);
}

void moveRight(){
    addNode();
    deleteNode();
    if(tail->row == 0 || tail->row == 20 || tail->column == 0 || tail->column == 20){
        initSnake();
    }
}
int main()
{
    initNcurse();
    initSnake();
    gamePic();
    int control;
    while(1){
        control = getch();
        if(control == KEY_RIGHT){
            moveRight();
            gamePic();
        }
    }
    
    getch();
    endwin();
    return 0;
}

向右自动移动

去掉按键判断，将向右移动放在死循环中每隔一段时间刷新一次

#include <curses.h>
#include <stdlib.h>

typedef struct Snake{
    int row;
    int column;
    struct Snake *next;
}Snake;

Snake *head = NULL;
Snake *tail = NULL;

void initNcurse(){
    initscr();
    keypad(stdscr,1);
}

int hasSnakeNode(int row,int column){
    Snake *p = head;
    while(p != NULL){
        if(p->row == row && p->column == column){
            return 1;
        }
        p = p->next;
    }
    return 0;
}

void gamePic(){
    int row;
    int column;
    
    move(0,0);
    
    for(row=0;row<20;row++){
        if(row == 0 || row == 19){
            for(column=0;column<20;column++){
                printw("--");
            }
            printw("\n");
        }
        
        if(row>0 && row<19){
            for(column=0;column<=20;column++){
                if(column==0 || column==20){
                    printw("|");
                }else if(hasSnakeNode(row,column)){
                    printw("[]");
                }else{
                    printw("  ");
                }
            }
            printw("\n");
        }
    }
}

void addNode(){
    Snake *newNode = (Snake *)malloc(sizeof(Snake));
    newNode->row = tail->row;
    newNode->column = tail->column + 1;
    newNode->next = NULL;
    
    tail->next = newNode;
    tail = newNode;
}

void initSnake(){
    Snake *p = NULL;
    while(head != NULL){
        p = head;
        head = head->next;
        free(p);
    }
    
    head = (Snake *)malloc(sizeof(Snake));
    head->row = 2;
    head->column = 2;
    head->next = NULL;
    
    tail = head;
    addNode();
    addNode();
    addNode();
}

void deleteNode(){
    Snake *node = head;
    head = head->next;
    free(node);
}

void moveRight(){
    addNode();
    deleteNode();
    if(tail->row == 0 || tail->row == 20 || tail->column == 0 || tail->column == 20){
        initSnake();
    }
}
int main()
{
    initNcurse();
    initSnake();
    gamePic();
    int control;
    while(1){
        moveRight();
        gamePic();
        refresh();
        usleep(100000);
    }
    
    getch();
    endwin();
    return 0;
}

开启一条新线程运行2个while(1)

#include <stdio.h>
#include <pthread.h>

void* func1(){
    while(1){
        printf("this is func1\n");
        sleep(1);
    }
}

void* func2(){
    while(1){
        printf("this is func2\n");
        sleep(1);
    }
}

int main()
{
    pthread_t th1;
    // start a new thread th1 to run func1
    pthread_create(&th1,NULL,func1,NULL);
    func2();
    return 0;
}

保存代码

gcc threadDemo -lpthread

./a.out

使用线程实现蛇向4个方向移动

初步实现开启2个新线程

一个线程不停移动蛇，一个线程不断接收方向按键变化

#include <curses.h>
#include <stdlib.h>
#include <pthread.h>

typedef struct Snake{
    int row;
    int column;
    struct Snake *next;
}Snake;

Snake *head = NULL;
Snake *tail = NULL;

void initNcurse(){
    initscr();
    keypad(stdscr,1);
}

int hasSnakeNode(int row,int column){
    Snake *p = head;
    while(p != NULL){
        if(p->row == row && p->column == column){
            return 1;
        }
        p = p->next;
    }
    return 0;
}

void gamePic(){
    int row;
    int column;
    
    move(0,0);
    
    for(row=0;row<20;row++){
        if(row == 0 || row == 19){
            for(column=0;column<20;column++){
                printw("--");
            }
            printw("\n");
        }
        
        if(row>0 && row<19){
            for(column=0;column<=20;column++){
                if(column==0 || column==20){
                    printw("|");
                }else if(hasSnakeNode(row,column)){
                    printw("[]");
                }else{
                    printw("  ");
                }
            }
            printw("\n");
        }
    }
}

void addNode(){
    Snake *newNode = (Snake *)malloc(sizeof(Snake));
    newNode->row = tail->row;
    newNode->column = tail->column + 1;
    newNode->next = NULL;
    
    tail->next = newNode;
    tail = newNode;
}

void initSnake(){
    Snake *p = NULL;
    while(head != NULL){
        p = head;
        head = head->next;
        free(p);
    }
    
    head = (Snake *)malloc(sizeof(Snake));
    head->row = 2;
    head->column = 2;
    head->next = NULL;
    
    tail = head;
    addNode();
    addNode();
    addNode();
}

void deleteNode(){
    Snake *node = head;
    head = head->next;
    free(node);
}

void moveRight(){
    addNode();
    deleteNode();
    if(tail->row == 0 || tail->row == 20 || tail->column == 0 || tail->column == 20){
        initSnake();
    }
}

void refreshPic(){
    while(1){
        moveRight();
        gamePic();
        refresh();
        usleep(100000);
    }
}

void changeDir(){
    int key;
    while(1){
        key = getch();
        switch(key){
            case KEY_DOWN:
                printw("DOWN\n");
                break;
            case KEY_UP:
                printw("UP\n");
                break;
            case KEY_LEFT:
                printw("LEFT\n");
                break;
            case KEY_RIGHT:
                printw("RIGHT\n");
                break;
        }
    }
}

int main()
{
    initNcurse();
    initSnake();
    gamePic();
    
    pthread_t th1;
    pthread_t th2;
    pthread_create(&th1,NULL,refreshPic,NULL);
    pthread_create(&th2,NULL,changeDir,NULL);
    
    while(1);
    getch();
    endwin();
    return 0;
}

gcc moveFourDirection.c -lcurses -lpthread

./a.out

初步实现蛇向4个方向移动

#include <curses.h>
#include <stdlib.h>
#include <pthread.h>

# define UP 1
# define DOWN 2
# define LEFT 3
# define RIGHT 4

typedef struct Snake{
    int row;
    int column;
    struct Snake *next;
}Snake;

Snake *head = NULL;
Snake *tail = NULL;

int direction;

void initNcurse(){
    initscr();
    keypad(stdscr,1);
}

int hasSnakeNode(int row,int column){
    Snake *p = head;
    while(p != NULL){
        if(p->row == row && p->column == column){
            return 1;
        }
        p = p->next;
    }
    return 0;
}

void gamePic(){
    int row;
    int column;
    
    move(0,0);
    
    for(row=0;row<20;row++){
        if(row == 0 || row == 19){
            for(column=0;column<20;column++){
                printw("--");
            }
            printw("\n");
        }
        
        if(row>0 && row<19){
            for(column=0;column<=20;column++){
                if(column==0 || column==20){
                    printw("|");
                }else if(hasSnakeNode(row,column)){
                    printw("[]");
                }else{
                    printw("  ");
                }
            }
            printw("\n");
        }
    }
}

void addNode(){
    Snake *newNode = (Snake *)malloc(sizeof(Snake));
    newNode->next = NULL;
    
    switch(direction){
        case UP:
            newNode->row = tail->row - 1;
            newNode->column = tail->column;
            break;
        case DOWN:
            newNode->row = tail->row + 1;
            newNode->column = tail->column;
            break;
        case LEFT:
            newNode->row = tail->row;
            newNode->column = tail->column - 1;
            break;
        case RIGHT:
            newNode->row = tail->row;
            newNode->column = tail->column + 1;
            break;
    }
    
    tail->next = newNode;
    tail = newNode;
}

void initSnake(){
    Snake *p = NULL;
    
    direction = RIGHT;
    
    while(head != NULL){
        p = head;
        head = head->next;
        free(p);
    }
    
    head = (Snake *)malloc(sizeof(Snake));
    head->row = 2;
    head->column = 2;
    head->next = NULL;
    
    tail = head;
    addNode();
    addNode();
    addNode();
}

void deleteNode(){
    Snake *node = head;
    head = head->next;
    free(node);
}

void moveRight(){
    addNode();
    deleteNode();
    if(tail->row == 0 || tail->row == 20 || tail->column == 0 || tail->column == 20){
        initSnake();
    }
}

void refreshPic(){
    while(1){
        moveRight();
        gamePic();
        refresh();
        usleep(100000);
    }
}

void changeDir(){
    int key;
    while(1){
        key = getch();
        switch(key){
            case KEY_DOWN:
                direction = DOWN;
                break;
            case KEY_UP:
                direction = UP;
                break;
            case KEY_LEFT:
                direction = LEFT;
                break;
            case KEY_RIGHT:
                direction = RIGHT;
                break;
        }
    }
}

int main()
{
    initNcurse();
    initSnake();
    gamePic();
    
    pthread_t th1;
    pthread_t th2;
    pthread_create(&th1,NULL,refreshPic,NULL);
    pthread_create(&th2,NULL,changeDir,NULL);
    
    while(1);
    getch();
    endwin();
    return 0;
}

用绝对值方式解决不合理走位

蛇能转向的根本是尾部朝不同方向添加新节点，头部删除节点

要让蛇方向改变的同时朝相应的方向自动移动，实时接收方向变化的指令->写在死循环里，自动移动->不断移动->写在死循环里，同时执行->开启2个线程

//实时改变方向
//按不同方向改变添加节点的坐标
//刷新画面让蛇不停移动
//开启2个线程分别执行变方向和刷新画面

#include <curses.h>
#include <stdlib.h>
#include <pthread.h>

# define UP 1
# define DOWN -1
# define LEFT 2
# define RIGHT -2

typedef struct Snake{
    int row;
    int column;
    struct Snake *next;
}Snake;

Snake *head = NULL;
Snake *tail = NULL;

int direction;

void initNcurse(){
    initscr();
    keypad(stdscr,1);
    noecho();
}

int hasSnakeNode(int row,int column){
    Snake *p = head;
    while(p != NULL){
        if(p->row == row && p->column == column){
            return 1;
        }
        p = p->next;
    }
    return 0;
}

void gamePic(){
    int row;
    int column;
    
    move(0,0);
    
    for(row=0;row<20;row++){
        if(row == 0 || row == 19){
            for(column=0;column<20;column++){
                printw("--");
            }
            printw("\n");
        }
        
        if(row>0 && row<19){
            for(column=0;column<=20;column++){
                if(column==0 || column==20){
                    printw("|");
                }else if(hasSnakeNode(row,column)){
                    printw("[]");
                }else{
                    printw("  ");
                }
            }
            printw("\n");
        }
    }
}

void addNode(){
    Snake *newNode = (Snake *)malloc(sizeof(Snake));
    newNode->next = NULL;
    
    switch(direction){
        case UP:
            newNode->row = tail->row - 1;
            newNode->column = tail->column;
            break;
        case DOWN:
            newNode->row = tail->row + 1;
            newNode->column = tail->column;
            break;
        case LEFT:
            newNode->row = tail->row;
            newNode->column = tail->column - 1;
            break;
        case RIGHT:
            newNode->row = tail->row;
            newNode->column = tail->column + 1;
            break;
    }
    
    tail->next = newNode;
    tail = newNode;
}

void initSnake(){
    Snake *p = NULL;
    
    direction = RIGHT;
    
    while(head != NULL){
        p = head;
        head = head->next;
        free(p);
    }
    
    head = (Snake *)malloc(sizeof(Snake));
    head->row = 2;
    head->column = 2;
    head->next = NULL;
    
    tail = head;
    addNode();
    addNode();
    addNode();
}

void deleteNode(){
    Snake *node = head;
    head = head->next;
    free(node);
}

void moveRight(){
    addNode();
    deleteNode();
    if(tail->row == 0 || tail->row == 20 || tail->column == 0 || tail->column == 20){
        initSnake();
    }
}

void refreshPic(){
    while(1){
        moveRight();
        gamePic();
        refresh();
        usleep(100000);
    }
}

void turn(int newDirection){
    if(abs(direction) != abs(newDirection)){
        direction = newDirection;
    }
}

void changeDir(){
    int key;
    while(1){
        key = getch();
        switch(key){
            case KEY_DOWN:
                turn(DOWN);
                break;
            case KEY_UP:
                turn(UP);
                break;
            case KEY_LEFT:
                turn(LEFT);
                break;
            case KEY_RIGHT:
                turn(RIGHT);
                break;
        }
    }
}

int main()
{
    initNcurse();
    initSnake();
    gamePic();
    
    pthread_t th1;
    pthread_t th2;
    pthread_create(&th1,NULL,refreshPic,NULL);
    pthread_create(&th2,NULL,changeDir,NULL);
    
    while(1);
    getch();
    endwin();
    return 0;
}

做贪吃蛇的食物

初步实现

//随机定义食物位置
//画食物
//蛇移动吃食物就随机产生下一个

#include <curses.h>
#include <stdlib.h>
#include <pthread.h>

# define UP 1
# define DOWN -1
# define LEFT 2
# define RIGHT -2

typedef struct Snake{
    int row;
    int column;
    struct Snake *next;
}Snake;

Snake *head = NULL;
Snake *tail = NULL;

int direction;

Snake food;
void initFood(){
    static int x = 4;
    static int y = 5;
    food.row = x;
    food.column = y;
    x+=2;
    y+=2;
}

void initNcurse(){
    initscr();
    keypad(stdscr,1);
    noecho();
}

int hasSnakeNode(int row,int column){
    Snake *p = head;
    while(p != NULL){
        if(p->row == row && p->column == column){
            return 1;
        }
        p = p->next;
    }
    return 0;
}

int hasFood(int row,int column){
    if(food.row == row && food.column == column){
        return 1;
    }
    return 0;
}

void gamePic(){
    int row;
    int column;
    
    move(0,0);
    
    for(row=0;row<20;row++){
        if(row == 0 || row == 19){
            for(column=0;column<20;column++){
                printw("--");
            }
            printw("\n");
        }
        
        if(row>0 && row<19){
            for(column=0;column<=20;column++){
                if(column==0 || column==20){
                    printw("|");
                }else if(hasSnakeNode(row,column)){
                    printw("[]");
                }else if(hasFood(row,column)){
                    printw("##");
                }else{
                    printw("  ");
                }
            }
            printw("\n");
        }
    }
}

void addNode(){
    Snake *newNode = (Snake *)malloc(sizeof(Snake));
    newNode->next = NULL;
    
    switch(direction){
        case UP:
            newNode->row = tail->row - 1;
            newNode->column = tail->column;
            break;
        case DOWN:
            newNode->row = tail->row + 1;
            newNode->column = tail->column;
            break;
        case LEFT:
            newNode->row = tail->row;
            newNode->column = tail->column - 1;
            break;
        case RIGHT:
            newNode->row = tail->row;
            newNode->column = tail->column + 1;
            break;
    }
    
    tail->next = newNode;
    tail = newNode;
}

void initSnake(){
    Snake *p = NULL;
    
    direction = RIGHT;
    
    while(head != NULL){
        p = head;
        head = head->next;
        free(p);
    }
    
    initFood();
    head = (Snake *)malloc(sizeof(Snake));
    head->row = 2;
    head->column = 2;
    head->next = NULL;
    
    tail = head;
    addNode();
    addNode();
    addNode();
}

void deleteNode(){
    Snake *node = head;
    head = head->next;
    free(node);
}

void moveRight(){
    addNode();
    
    if(hasFood(tail->row,tail->column){
        initFood();
    }else{
        deleteNode(); 
    }
    
    if(tail->row == 0 || tail->row == 20 || tail->column == 0 || tail->column == 20){
        initSnake();
    }
}

void refreshPic(){
    while(1){
        moveRight();
        gamePic();
        refresh();
        usleep(100000);
    }
}

void turn(int newDirection){
    if(abs(direction) != abs(newDirection)){
        direction = newDirection;
    }
}

void changeDir(){
    int key;
    while(1){
        key = getch();
        switch(key){
            case KEY_DOWN:
                turn(DOWN);
                break;
            case KEY_UP:
                turn(UP);
                break;
            case KEY_LEFT:
                turn(LEFT);
                break;
            case KEY_RIGHT:
                turn(RIGHT);
                break;
        }
    }
}

int main()
{
    initNcurse();
    initSnake();
    gamePic();
    
    pthread_t th1;
    pthread_t th2;
    pthread_create(&th1,NULL,refreshPic,NULL);
    pthread_create(&th2,NULL,changeDir,NULL);
    
    while(1);
    getch();
    endwin();
    return 0;
}

吃掉食物让食物随机产生

#include <curses.h>
#include <stdlib.h>
#include <pthread.h>

# define UP 1
# define DOWN -1
# define LEFT 2
# define RIGHT -2

typedef struct Snake{
    int row;
    int column;
    struct Snake *next;
}Snake;

Snake *head = NULL;
Snake *tail = NULL;

int direction;

Snake food;
void initFood(){
    int x = rand()%20;
    int y = rand()%20;
    food.row = x;
    food.column = y;
}

void initNcurse(){
    initscr();
    keypad(stdscr,1);
    noecho();
}

int hasSnakeNode(int row,int column){
    Snake *p = head;
    while(p != NULL){
        if(p->row == row && p->column == column){
            return 1;
        }
        p = p->next;
    }
    return 0;
}

int hasFood(int row,int column){
    if(food.row == row && food.column == column){
        return 1;
    }
    return 0;
}

void gamePic(){
    int row;
    int column;
    
    move(0,0);
    
    for(row=0;row<20;row++){
        if(row == 0 || row == 19){
            for(column=0;column<20;column++){
                printw("--");
            }
            printw("\n");
        }
        
        if(row>0 && row<19){
            for(column=0;column<=20;column++){
                if(column==0 || column==20){
                    printw("|");
                }else if(hasSnakeNode(row,column)){
                    printw("[]");
                }else if(hasFood(row,column)){
                    printw("##");
                }else{
                    printw("  ");
                }
            }
            printw("\n");
        }
    }
}

void addNode(){
    Snake *newNode = (Snake *)malloc(sizeof(Snake));
    newNode->next = NULL;
    
    switch(direction){
        case UP:
            newNode->row = tail->row - 1;
            newNode->column = tail->column;
            break;
        case DOWN:
            newNode->row = tail->row + 1;
            newNode->column = tail->column;
            break;
        case LEFT:
            newNode->row = tail->row;
            newNode->column = tail->column - 1;
            break;
        case RIGHT:
            newNode->row = tail->row;
            newNode->column = tail->column + 1;
            break;
    }
    
    tail->next = newNode;
    tail = newNode;
}

void initSnake(){
    Snake *p = NULL;
    
    direction = RIGHT;
    
    while(head != NULL){
        p = head;
        head = head->next;
        free(p);
    }
    
    initFood();
    head = (Snake *)malloc(sizeof(Snake));
    head->row = 2;
    head->column = 2;
    head->next = NULL;
    
    tail = head;
    addNode();
    addNode();
    addNode();
}

void deleteNode(){
    Snake *node = head;
    head = head->next;
    free(node);
}

void moveRight(){
    addNode();
    
    if(hasFood(tail->row,tail->column){
        initFood();
    }else{
        deleteNode(); 
    }
    
    if(tail->row == 0 || tail->row == 20 || tail->column == 0 || tail->column == 20){
        initSnake();
    }
}

void refreshPic(){
    while(1){
        moveRight();
        gamePic();
        refresh();
        usleep(100000);
    }
}

void turn(int newDirection){
    if(abs(direction) != abs(newDirection)){
        direction = newDirection;
    }
}

void changeDir(){
    int key;
    while(1){
        key = getch();
        switch(key){
            case KEY_DOWN:
                turn(DOWN);
                break;
            case KEY_UP:
                turn(UP);
                break;
            case KEY_LEFT:
                turn(LEFT);
                break;
            case KEY_RIGHT:
                turn(RIGHT);
                break;
        }
    }
}

int main()
{
    initNcurse();
    initSnake();
    gamePic();
    
    pthread_t th1;
    pthread_t th2;
    pthread_create(&th1,NULL,refreshPic,NULL);
    pthread_create(&th2,NULL,changeDir,NULL);
    
    while(1);
    getch();
    endwin();
    return 0;
}

修复贪吃蛇往上不到墙就死和咬不死自己的问题

//如果蛇撞到墙或咬到自己就初始化蛇身

#include <curses.h>
#include <stdlib.h>
#include <pthread.h>

# define UP 1
# define DOWN -1
# define LEFT 2
# define RIGHT -2

typedef struct Snake{
    int row;
    int column;
    struct Snake *next;
}Snake;

Snake *head = NULL;
Snake *tail = NULL;

int direction;

Snake food;
void initFood(){
    int x = rand()%20;
    int y = rand()%20;
    food.row = x;
    food.column = y;
}

void initNcurse(){
    initscr();
    keypad(stdscr,1);
    noecho();
}

int hasSnakeNode(int row,int column){
    Snake *p = head;
    while(p != NULL){
        if(p->row == row && p->column == column){
            return 1;
        }
        p = p->next;
    }
    return 0;
}

int hasFood(int row,int column){
    if(food.row == row && food.column == column){
        return 1;
    }
    return 0;
}

void gamePic(){
    int row;
    int column;
    
    move(0,0);
    
    for(row=0;row<20;row++){
        if(row == 0 || row == 19){
            for(column=0;column<20;column++){
                printw("--");
            }
            printw("\n");
        }
        
        if(row>0 && row<19){
            for(column=0;column<=20;column++){
                if(column==0 || column==20){
                    printw("|");
                }else if(hasSnakeNode(row,column)){
                    printw("[]");
                }else if(hasFood(row,column)){
                    printw("##");
                }else{
                    printw("  ");
                }
            }
            printw("\n");
        }
    }
}

void addNode(){
    Snake *newNode = (Snake *)malloc(sizeof(Snake));
    newNode->next = NULL;
    
    switch(direction){
        case UP:
            newNode->row = tail->row - 1;
            newNode->column = tail->column;
            break;
        case DOWN:
            newNode->row = tail->row + 1;
            newNode->column = tail->column;
            break;
        case LEFT:
            newNode->row = tail->row;
            newNode->column = tail->column - 1;
            break;
        case RIGHT:
            newNode->row = tail->row;
            newNode->column = tail->column + 1;
            break;
    }
    
    tail->next = newNode;
    tail = newNode;
}

void initSnake(){
    Snake *p = NULL;
    
    direction = RIGHT;
    
    while(head != NULL){
        p = head;
        head = head->next;
        free(p);
    }
    
    initFood();
    head = (Snake *)malloc(sizeof(Snake));
    head->row = 2;
    head->column = 2;
    head->next = NULL;
    
    tail = head;
    addNode();
    addNode();
    addNode();
}

void deleteNode(){
    Snake *node = head;
    head = head->next;
    free(node);
}

int ifSnakeDie(){
    Snake *node = head;
    if(tail->row < 0 || tail->row == 20 || tail->column == 0 || tail->column == 20){
        return 1;
    }
    while(node->next != NULL){
        if(node->row == tail->row && node->column == tail->column){
            return 1;
        }
        node = node->next;
    }
}

void moveRight(){
    addNode();
    
    if(hasFood(tail->row,tail->column){
        initFood();
    }else{
        deleteNode(); 
    }
    
    if(ifSnakeDie()){
        initSnake();
    }
}

void refreshPic(){
    while(1){
        moveRight();
        gamePic();
        refresh();
        usleep(100000);
    }
}

void turn(int newDirection){
    if(abs(direction) != abs(newDirection)){
        direction = newDirection;
    }
}

void changeDir(){
    int key;
    while(1){
        key = getch();
        switch(key){
            case KEY_DOWN:
                turn(DOWN);
                break;
            case KEY_UP:
                turn(UP);
                break;
            case KEY_LEFT:
                turn(LEFT);
                break;
            case KEY_RIGHT:
                turn(RIGHT);
                break;
        }
    }
}

int main()
{
    initNcurse();
    initSnake();
    gamePic();
    
    pthread_t th1;
    pthread_t th2;
    pthread_create(&th1,NULL,refreshPic,NULL);
    pthread_create(&th2,NULL,changeDir,NULL);
    
    while(1);
    getch();
    endwin();
    return 0;
}

完整贪吃蛇思路

简洁版：

//初始化nurse
//画地图
//初始化画蛇身
//开启2个线程分别实时变向和根据方向自动移动
//初始化随机位置食物
//蛇吃食物就产生下一个随机食物并且变长
//蛇撞墙或咬到自己就重新开始

详细版：

//初始化ncurse
//画地图
//定义蛇身
//初始化蛇身
//添加蛇身
//画蛇身
//判断按键如果向右
//蛇向右移动
注意在画图的方法中添加move(0,0);
如果蛇的坐标到了墙的地方就初始化蛇
去掉按键判断，将向右移动放在死循环中每隔一段时间刷新一次
//实时改变方向
//按不同方向改变添加节点的坐标
//刷新画面让蛇不停移动
//开启2个线程分别执行变方向和刷新画面
//随机定义食物位置
//画食物
//蛇移动吃食物就随机产生下一个
//如果蛇撞到墙或咬到自己就初始化蛇身
CSDN_Xian
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
linux 剪刀石头布c语言,利用C语言编写“剪刀石头布”小游戏
weixin_29476755的博客
05-13 1641
前言大家好~我是一名C语言初学者，学了C语言基础后，我制作了一个小游戏：剪刀石头布。希望大家能对我的思路和代码提出小Tips(eg.更简便的方法与程序)我也会虚心接受大家的建议~一、游戏原理“剪刀石头布”这个游戏，想必大家都很熟悉了。两个人在玩游戏时，事先都不知道对方将要出什么，这中间存在着一种随机性。而这种随机性相当于C语言里stdlib.h库中rand()函数，rand()函数用来产生随机数，...
Linux下C语言吃豆小游戏,吃豆人游戏C语言源代码.docx
weixin_34505281的博客
05-14 847
北京科技大学 计算机与通信工程学院 信息1008 庄辉#include "graphics.h"#include "stdlib.h"#include "dos.h"#include "bios.h"#include "stdio.h"#include "time.h"#include "graphics.h"#include "conio.h"#define LEFT 0x4b00#define...
推箱子小游戏（萌新小游戏 基于Linux C语言实现）
qq_53032356的博客
02-19 1148
基于Linux下使用c语言完成的推箱子小游戏
linux下的c语言实现象棋,【C语言小游戏】 中国象棋
weixin_36296864的博客
05-14 500
人人对战chunli@Linux:~$catmain.c//main.c//象棋//車马相仕帅仕相马車//十十十十十十十十十//十炮十十十十十炮十//兵十兵十兵十兵十兵//十十十十十十十十十//－－楚河－汉界－－//十十十十十十十十十//卒十卒十卒十卒十卒//十炮十十十十十炮十//十十十十十十十十十//車马象士将士象马車//#include...
猜拳游戏（C语言-Linux-简单可视化）
Half-up的博客
03-31 1289
注释很详细，可以看看 #include <gtk/gtk.h> #include <time.h> void show(GtkButton *button, gpointer user_data); void replay(GtkButton *button,gpointer user_data); //GtkWidget是GTK+控件类型，GtkWidget * 能指向任何控件的指针类型。 GtkWidget* l_4; GtkWidget* l_5; GtkWidget* l_6
在linux下用C语言编写贪吃蛇小游戏
weixin_44263604的博客
08-06 3788
利用链表和结构体来编写贪吃蛇小游戏，这边还会用点线程，分别有以下模块： 1、地图规划 2、蛇身体的初始化 3、蛇的方向移动 4、食物的初始化和随机出现 5、蛇撞墙和咬自己的尾巴 地图规划 我们在设计地图的时候，需要用到ncurses，头文件 #include <curses.h> ncurses（new curses）是一个程序库，它提供了API，可以允许程序员编写独立于终端的基...
C语言贪吃蛇Linux版
小川先生的博客
12-20 4200
/* ======================================= */Update: 20170713新版贪吃蛇：传送门/* ======================================= */ 最近闲来无事用C语言写了个贪吃蛇解解闷, 其实这玩意儿也不难写, 其一就是如何绘制蛇和背景, 其二就是怎么把用户的输入实现成蛇的转向. 我这里使用了curses.h
C语言贪吃蛇（控制台版）
最新发布
07-21
这是一个简单的控制台版贪吃蛇游戏，使用C语言编写。 项目架构 main.c： 主程序 game.h: 游戏主逻辑 menu.h: 菜单显示 snake.h： 贪吃蛇逻辑实现 structs.h: 数据结构定义 utils.h: 工具函数定义 settings.h: 设置...
C语言控制台版贪吃蛇游戏.rar
08-09
用C和C++并用写的贪吃蛇游戏，写的比较仓促，没有把各个功能区分开，游戏有闯关模式，有经典的诺基亚那种没有墙壁的模式，有随机地图模式，也支持自己创建地图。地图中有五种地形 空地 草地 墙壁 酒瓶 和传送门 其中...
c语言控制台贪吃蛇小游戏
06-05
【C语言控制台贪吃蛇小游戏】是一款基于C语言编程实现的经典游戏，它在命令行界面（控制台）上运行，具有丰富的交互性和趣味性。这款游戏的代码结构相对复杂，包含六百多行，体现了C语言的强大功能和编程者的精湛...
贪吃蛇（控制台游戏C语言）
10-27
在C语言中实现贪吃蛇游戏，开发者需要掌握基本的C编程语法、控制台输入输出、结构体、循环、条件判断等核心概念。下面我们将深入探讨这些知识点。 首先，C语言是计算机科学的基础，它是一种低级但高效的编程语言，...
c语言贪吃蛇游戏的双人对战版
06-27
c语言贪吃蛇游戏的双人对战版c语言贪吃蛇游戏的双人对战版c语言贪吃蛇游戏的双人对战版c语言贪吃蛇游戏的双人对战版c语言贪吃蛇游戏的双人对战版c语言贪吃蛇游戏的双人对战版c语言贪吃蛇游戏的双人对战版c语言贪吃蛇...
基于Linux环境中C语言程序----Hello World
WeiComp
07-10 3179
基于Linux操作系统学习C语言
【C语言】贪吃蛇(Linux环境)
weixin_47211766的博客
02-25 467
用链表实现简易版贪吃蛇
linux-c语言练手——贪吃蛇小游戏
SCT_CX的博客
02-08 565
贪吃蛇
linux简易扫雷c语言代码,C语言代码实现简单扫雷小游戏
weixin_28977123的博客
05-13 221
用C语言写一个简单的扫雷，供大家参考，具体内容如下1.所需要的知识c语言的基本语法，简单的二维数组，一点简单的递归知识。2.总体思路扫雷游戏主要由3个部分组成，埋雷子，扫雷，判断输赢。扫雷游戏的主体是两个个字符类型的二维数组。一个是mine[][]它的构成是'0'和‘1',其中'0'表示无雷，'1'表示有雷。一个是show[][]它的构成是'*'和'数字'。星号表示未开启的地方，数字表示周围的雷数...
用C语言编写一个俄罗斯方块小游戏
weixin_48856218的博客
04-22 622
#include <stdio.h> #include <string.h> #include <stdlib.h> #include <time.h> #include <conio.h> #include <windows.h> #ifdef _MSC_VER #if _MSC_VER <= 1200 #error ？ #else #if _MSC_VER >= 1600 #include &lt
【Linux】用C语言实现第一个小程序——“进度条”
来自B612星球
11-12 945
sleep()函数库文件sleep(3)程序休眠3秒后退出unistd.h是unix std的意思，包含了许多UNIX系统服务的函数原型。1. 两个补充 1.1).makefile文件编写 1.2). 介绍休眠函数 现象 1.3倒计时 2. 文件创建+链接 3. Vision 1. 入门版 3.0 代码 4. Vision 2 4.1 download场景模拟 4.2 结合应用案例(download) 4.3 字符颜色 5. 文章源代码
gcc -D选项定义宏
CSDN_Xian的博客
02-02 4145
文章目录概念实验 概念 gcc的-D选项可以定义宏。 假设程序需要很多宏，不可能这些宏都在编译器中定义，可以说比较重要的宏才会放在gcc的D选项后边。 -Dname 定义宏name,默认定义内容为字符串“1" -Dname=defn 定义宏name，并且内容为defn 实验 测试程序：#include <stdio.h> int main() { #ifdef HELLO printf("HELLO defined !\n"); printf("HELLO = %d\n
C语言实现贪吃蛇游戏源码解析
在C语言中编写贪吃蛇游戏涉及到许多基础的编程概念和技术，包括结构体、链表操作、控制台输出、事件处理以及循环等。以下是对该源代码中涉及的知识点的详细解释： 1. **结构体定义**： `typedef struct SNAKE` ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值