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

最新推荐文章于 2023-11-12 19:39:02 发布
最新推荐文章于 2023-11-12 19:39:02 发布
阅读量265 收藏 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 1638
前言大家好~我是一名C语言初学者，学了C语言基础后，我制作了一个小游戏：剪刀石头布。希望大家能对我的思路和代码提出小Tips(eg.更简便的方法与程序)我也会虚心接受大家的建议~一、游戏原理“剪刀石头布”这个游戏，想必大家都很熟悉了。两个人在玩游戏时，事先都不知道对方将要出什么，这中间存在着一种随机性。而这种随机性相当于C语言里stdlib.h库中rand()函数，rand()函数用来产生随机数，...
linux-c语言练手——贪吃蛇小游戏
SCT_CX的博客
02-08 553
贪吃蛇
推箱子小游戏（萌新小游戏 基于Linux C语言实现）
qq_53032356的博客
02-19 1141
基于Linux下使用c语言完成的推箱子小游戏
猜拳游戏（C语言-Linux-简单可视化）
Half-up的博客
03-31 1284
注释很详细，可以看看 #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语言吃豆小游戏,吃豆人游戏C语言源代码.docx
weixin_34505281的博客
05-14 846
北京科技大学 计算机与通信工程学院 信息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语言编写贪吃蛇小游戏
weixin_44263604的博客
08-06 3780
利用链表和结构体来编写贪吃蛇小游戏，这边还会用点线程，分别有以下模块： 1、地图规划 2、蛇身体的初始化 3、蛇的方向移动 4、食物的初始化和随机出现 5、蛇撞墙和咬自己的尾巴 地图规划 我们在设计地图的时候，需要用到ncurses，头文件 #include <curses.h> ncurses（new curses）是一个程序库，它提供了API，可以允许程序员编写独立于终端的基...
C语言贪吃蛇Linux版
小川先生的博客
12-20 4199
/* ======================================= */Update: 20170713新版贪吃蛇：传送门/* ======================================= */ 最近闲来无事用C语言写了个贪吃蛇解解闷, 其实这玩意儿也不难写, 其一就是如何绘制蛇和背景, 其二就是怎么把用户的输入实现成蛇的转向. 我这里使用了curses.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语言贪吃蛇...
贪吃蛇C语言控制台
03-16
以上是贪吃蛇C语言控制台版实现的主要步骤和关键知识点。通过这个项目，不仅可以巩固C语言的基础，还能提升对游戏逻辑的理解和编程技巧的运用。对于初学者来说，这是一个很好的实践项目，能够锻炼编程思维，加深对...
【Linux】用C语言实现第一个小程序——“进度条”
来自B612星球
11-12 895
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. 文章源代码
用C语言编写一个俄罗斯方块小游戏
weixin_48856218的博客
04-22 620
#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语言程序----Hello World
WeiComp
07-10 3161
基于Linux操作系统学习C语言
扫雷游戏（C语言版）
qq2977078774的博客
11-08 1913
一、扫雷的游戏规则 这款游戏的玩法是在自定义大小的方块矩阵中随机布置一定量的地雷。由玩家逐个翻开方块，以找出所有地雷为最终游戏目标。使用鼠标左键随机点击一个方格，方格即被打开并显示出方格中的数字；方格中数字则表示其周围的8个方格隐藏了几颗雷。如果玩家翻开的方块有地雷，则游戏结束。 　 二、扫雷游戏的基本实现思路（基本流程） 建立一个游戏菜单 创建一个棋盘并将其初始化 将初始化后的棋盘进行打印 玩家落子并打印棋盘(玩家输入行列坐标的方式来落子) 判定胜负关系（玩家是否获胜？有则直接游戏结束无则继续进行）
【C语言】贪吃蛇(Linux环境)
weixin_47211766的博客
02-25 446
用链表实现简易版贪吃蛇
Linux下C语言实现俄罗斯方块——详细版
q3415597181的博客
09-07 4526
1、创建界面map数组边界填充值 1。2、rand生成随机数确定下移的图形。3、界面显示，通过移动光标输出确定界面位置。4、图形显示，通过光标移动输出图形，四个数据块每一块对应一个小方块。下一个输出next为 反L3：{(0,0), (1,0), (0,1), (0,2)}。5、图形下移，通过y变化改变位置下移。6、下移完成，判断图形到界面边界，将图形到达位置写入map， map填充值2。
gcc -D选项定义宏
CSDN_Xian的博客
02-02 4098
文章目录概念实验 概念 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语言控制台贪吃蛇游戏的小矩形
06-01
以下是使用C语言打出控制台贪吃蛇游戏的小矩形的示例代码： ```c #include <stdio.h> int main() { printf("■\n"); printf("■■\n"); printf("■■■\n"); printf("■■■■\n"); return 0; } ``` 这段代码会在控制台打印出一个小矩形，由四个方块组成。每个方块使用Unicode字符“■”表示。你可以根据需要修改代码来调整小矩形的大小和位置。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值