【C语言学习笔记】终端下贪吃蛇游戏

最新推荐文章于 2023-03-04 20:03:53 发布
最新推荐文章于 2023-03-04 20:03:53 发布
阅读量3.5k 收藏 3
点赞数 1
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wusuopuBUPT/article/details/17723413
版权

一直渴望写一个自己的贪吃蛇游戏，看完国外网友的代码后发现，自己的能力还是不足以“手写”出这样一个属于自己的程序。这段代码存在github上已经3周了，尽管我想等自己完全能够手写出自己的程序，但却还是不想把这篇早该完成的博客留在明年。


这里要用到cursers库以管理基于文本的屏幕（http://heather.cs.ucdavis.edu/~matloff/UnixAndC/CLanguage/Curses.pdf）


1.各项初始化工作：


void init() {
        initscr();//屏幕控制初始化，如果成功，返回一个只想stdscr结构的指针
        raw(); //关闭特殊字符的处理
        noecho();//关闭输入字符的回显功能
        keypad(stdscr, TRUE); 
        curs_set(0);
        nodelay(stdscr, TRUE);
}

keypad模式： 

int keypad(WINDOW *window_ptr, bool keypad_on);

在keypad模式中，curses将接管按键转义序列的处理功能，读键盘操作不仅能够返回用户按下的键，还将返回与逻辑按键相对应的KEY_定义。


2.用结构体表示snack和food：

struct Snack {
    int x[100];
    int y[100];
    int node;
    int life;
    int direction;
} snack;

struct Food {
        int X, Y;
        int set;
} food;

3.打印出snack和food:

void draw() {
        snack.x[0] = 6;
        snack.y[0] = 3;
        snack.x[1] = 5;
        snack.y[1] = 3;
        snack.x[2] = 4;
        snack.y[2] = 3;
        snack.life = 0;
        snack.node = 3;
        snack.direction = 4;
        food.set = 0;
        color();
        d_e();
        for (i = 0; i < snack.node; i++)
                mvprintw(snack.y[i], snack.x[i], "*");
        refresh();

        timer = time(NULL);
}

mvprintw()函数：

int myprintw(int y, int x, char *format, ...)
在指定的位置打印(x,y)字符串format.

随机生成food: 

if (food.set == 0) {
	food.X = rand() % 50;
	while (food.X == 0 || food.X == 49)
	    food.X = rand() % 50;
	food.Y = rand() % 20;
	while (food.Y == 0 || food.Y == 19)
	    food.Y = rand() % 20;
	food.set = 1;
}


4.打印四面墙


void color() {
        start_color();
        init_pair(1, COLOR_GREEN, COLOR_RED);
        attron(COLOR_PAIR(1));
        for (i = 0; i < 50; i++)
                mvaddch(0, i, '*');
        for (i = 0; i < 20; i++)
                mvaddch(i, 0, '*');
        for (i = 49; i >= 0; i--)
                mvaddch(19, i, '*');
        for (i = 19; i >= 0; i--)
                mvaddch(i, 49, '*'); //box(stdscr,'*','*');

        attroff(COLOR_PAIR(1));
}

start_color()函数对curses的颜色例程进行初始化

init_pair()函数对准备使用的颜色组合进行初始化

attron()函数在不影响其他属性的前提下启用制定的属性


5.判断前进方向：

void judge() {
        if (snack.direction == 1) //up
                snack.y[0]--;
        else if (snack.direction == 2)//down
                snack.y[0]++;
        else if (snack.direction == 3)//left
                snack.x[0]--;
        else //right
                snack.x[0]++;
}


ch = getch();
                switch (ch) {
                case (KEY_UP):
                        if (snack.direction == 3 || snack.direction == 4) {
                                snack.y[0]--;
                                snack.direction = 1;
                        } else if (snack.direction == 1)
                                snack.y[0]--;
                        else
                                snack.y[0]++;
                        break;
                case (KEY_DOWN):
                        if (snack.direction == 3 || snack.direction == 4) {
                                snack.y[0]++;
                                snack.direction = 2;
                        } else if (snack.direction == 1)
                                snack.y[0]--;
                        else
                                snack.y[0]++;
                        break;
                case (KEY_LEFT):
                        if (snack.direction == 1 || snack.direction == 2) {
                                snack.x[0]--;
                                snack.direction = 3;
                        } else if (snack.direction == 3)
                                snack.x[0]--;
                        else
                                snack.x[0]++;
                        break;
                case (KEY_RIGHT):
                        if (snack.direction == 1 || snack.direction == 2) {
                                snack.x[0]++;
                                snack.direction = 4;
                        } else if (snack.direction == 3)
                                snack.x[0]--;
                        else
                                snack.x[0]++;
                        break;


6.蛇吃到食物 

if (snack.x[0] == food.X && snack.y[0] == food.Y) {
			food.set = 0;
			snack.node++;
			score += 10;
			for (i = snack.node - 1; i > 0; i--) {
				snack.x[i] = snack.x[i - 1];
				snack.y[i] = snack.y[i - 1];
			}
			judge();
		}

7.游戏结束的判断

if ((snack.x[0] == snack.x[i] && snack.y[0] == snack.y[i])
					|| snack.x[0] == 0 || snack.y[0] == 0 || snack.x[0] == 49
					|| snack.y[0] == 19) {
				for (i = 1; i < snack.node; i++) {
					snack.x[i - 1] = snack.x[i];
					snack.y[i - 1] = snack.y[i];
				}
				snack.y[snack.node - 1] = tem[0];
				snack.x[snack.node - 1] = tem[1];
				for (i = 0; i < snack.node; i++)
					mvprintw(snack.y[i], snack.x[i], "*");
				mvaddch(food.Y, food.X, '*');
				start_attr();
				mvprintw(10, 10, "You lose!");
				mvprintw(11, 10, "Do you want again?(y/n)");
				output();
				snack.life = 1;
				//sleep(1);

				break;
			}



完整程序如下：（编译命令：gcc snack.c -lcurses -o snack）

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

struct Snack {
        int x[100], y[100];
        int node;
        int life;
        int direction;
} snack;

struct Food {
        int X, Y;
        int set;
} food;

struct timespec delay;
struct timespec dummy;
time_t timer;
int TIME = 0;
long Time, Time1 = 0, Time2 = 0;
int ptime[100];
int score = 0;
int i, tem[2], k = 0;
void color();
void init();
void draw();
void start_attr();
void output();
void play();
void judge();
int pause_time(int, int *);
void d_e();

int main(int argc, char **argv) {

        init();
        draw();
        play();
        return 0;
}

void d_e() {
        int location = 18;
        int ch2 = KEY_LEFT, which = 0;
        char str[2][5] = { "Easy", "Hard" };
        while (ch2 != '\n') {

                switch (ch2) {
                case (KEY_LEFT):
                        if (location != 18) {
                                location -= 10;
                                which = 0;
                        }
                        break;
                case (KEY_RIGHT):
                        if (location == 18) {
                                location += 10;
                                which = 1;
                        }
                        break;
                }
                mvprintw(8, 10, "Please choose the difficulty!");
                mvprintw(10, 23, "^_^");
                mvprintw(12, 18, "Easy");
                mvprintw(12, 28, "Hard");
                attron(A_REVERSE);
                mvprintw(12, location, "%s", str[which]);
                attroff(A_REVERSE);
                refresh();
                ch2 = getch();
        }
        /*Time2=time(NULL);
         ptime[k]=Time2-Time1;
         k++; */
        if (location == 28)
                delay.tv_nsec = 100000000;
        else
                delay.tv_nsec = 200000000;
}

int pause_time(int k, int *PTIME) {
        int j;
        int sum = 0;
        for (j = 0; j < k; j++)
                sum = sum + ptime[j];
        return sum;
}
void judge() {
        if (snack.direction == 1)
                snack.y[0]--;
        else if (snack.direction == 2)
                snack.y[0]++;
        else if (snack.direction == 3)
                snack.x[0]--;
        else
                snack.x[0]++;
}
void color() {
        start_color();
        init_pair(1, COLOR_GREEN, COLOR_RED);
        attron(COLOR_PAIR(1));
        for (i = 0; i < 50; i++)
                mvaddch(0, i, '*');
        for (i = 0; i < 20; i++)
                mvaddch(i, 0, '*');
        for (i = 49; i >= 0; i--)
                mvaddch(19, i, '*');
        for (i = 19; i >= 0; i--)
                mvaddch(i, 49, '*'); //box(stdscr,'*','*');

        attroff(COLOR_PAIR(1));
}
void init() {
        initscr();
        raw();
        noecho();
        keypad(stdscr, TRUE);
        curs_set(0);
        nodelay(stdscr, TRUE);
}
void draw() {
        snack.x[0] = 6;
        snack.y[0] = 3;
        snack.x[1] = 5;
        snack.y[1] = 3;
        snack.x[2] = 4;
        snack.y[2] = 3;
        snack.life = 0;
        snack.node = 3;
        snack.direction = 4;
        food.set = 0;
        color();
        d_e();
        for (i = 0; i < snack.node; i++)
                mvprintw(snack.y[i], snack.x[i], "*");
        refresh();

        timer = time(NULL);
}
void output() {
        color();
        mvprintw(20, 0, "Score=%d", score);
        mvprintw(20, 43, "Node=%d", snack.node);
        mvprintw(21, 0, "Time=%ds", TIME);
        attroff(A_REVERSE);
        refresh();
}
void start_attr() {
        attron(A_REVERSE);
}

void play() {
        while (1) {
                Time = time(NULL);
                TIME = Time - timer - pause_time(k, ptime);
                clear();
                if (food.set == 0) {
                        food.X = rand() % 50;
                        while (food.X == 0 || food.X == 49)
                                food.X = rand() % 50;
                        food.Y = rand() % 20;
                        while (food.Y == 0 || food.Y == 19)
                                food.Y = rand() % 20;
                        food.set = 1;
                }
                tem[0] = snack.y[snack.node - 1];
                tem[1] = snack.x[snack.node - 1];
                for (i = snack.node - 1; i > 0; i--) {
                        snack.x[i] = snack.x[i - 1];
                        snack.y[i] = snack.y[i - 1];
                }
                int ch = 0;
                ch = getch();
                switch (ch) {
                case (KEY_UP):
                        if (snack.direction == 3 || snack.direction == 4) {
                                snack.y[0]--;
                                snack.direction = 1;
                        } else if (snack.direction == 1)
                                snack.y[0]--;
                        else
                                snack.y[0]++;
                        break;
                case (KEY_DOWN):
                        if (snack.direction == 3 || snack.direction == 4) {
                                snack.y[0]++;
                                snack.direction = 2;
                        } else if (snack.direction == 1)
                                snack.y[0]--;
                        else
                                snack.y[0]++;
                        break;
                case (KEY_LEFT):
                        if (snack.direction == 1 || snack.direction == 2) {
                                snack.x[0]--;
                                snack.direction = 3;
                        } else if (snack.direction == 3)
                                snack.x[0]--;
                        else
                                snack.x[0]++;
                        break;
                case (KEY_RIGHT):
                        if (snack.direction == 1 || snack.direction == 2) {
                                snack.x[0]++;
                                snack.direction = 4;
                        } else if (snack.direction == 3)
                                snack.x[0]--;
                        else
                                snack.x[0]++;
                        break;
                case 'p':
                case 'P':
                        Time1 = time(NULL);
                        judge();
                        for (i = 0; i < snack.node; i++)
                                mvprintw(snack.y[i], snack.x[i], "*");
                        mvaddch(food.Y, food.X, '*');
                        start_attr();
                        mvprintw(9, 10, "Pause!Press 'p' to continue!");
                        output();
                        while (getch() != 'p')
                                ;
                        Time2 = time(NULL);
                        ptime[k] = Time2 - Time1;
                        k++;
                        break;

                case 'q':
                case 'Q':
                        Time1 = time(NULL);
                        judge();
                        for (i = 0; i < snack.node; i++)
                                mvprintw(snack.y[i], snack.x[i], "*");

                        mvaddch(food.Y, food.X, '*');
                        start_attr();
                        mvprintw(10, 22, "Quit!");
                        output();
                        int location = 18;
                        int ch2 = KEY_LEFT, which = 0;
                        char str[2][5] = { "No", "Yes" };
                        while (ch2 != '\n') {

                                switch (ch2) {
                                case (KEY_LEFT):
                                        if (location != 18) {
                                                location -= 10;
                                                which = 0;
                                        }
                                        break;
                                case (KEY_RIGHT):
                                        if (location == 18) {
                                                location += 10;
                                                which = 1;
                                        }
                                        break;
                                }
                                mvprintw(12, 18, "No");
                                mvprintw(12, 28, "Yes");
                                attron(A_REVERSE);
                                mvprintw(12, location, "%s", str[which]);
                                attroff(A_REVERSE);
                                refresh();
                                ch2 = getch();
                        }
                        Time2 = time(NULL);
                        ptime[k] = Time2 - Time1;
                        k++;
                        if (location == 18)
                                break;
                        else {
                                clear();
                                endwin();
                                exit(1);
                        }
                default:
                        judge();
                        break;
                }
                for (i = 1; i < snack.node; i++)
                        if ((snack.x[0] == snack.x[i] && snack.y[0] == snack.y[i])
                                        || snack.x[0] == 0 || snack.y[0] == 0 || snack.x[0] == 49
                                        || snack.y[0] == 19) {
                                for (i = 1; i < snack.node; i++) {
                                        snack.x[i - 1] = snack.x[i];
                                        snack.y[i - 1] = snack.y[i];
                                }
                                snack.y[snack.node - 1] = tem[0];
                                snack.x[snack.node - 1] = tem[1];
                                for (i = 0; i < snack.node; i++)
                                        mvprintw(snack.y[i], snack.x[i], "*");
                                mvaddch(food.Y, food.X, '*');
                                start_attr();
                                mvprintw(10, 10, "You lose!");
                                mvprintw(11, 10, "Do you want again?(y/n)");
                                output();
                                snack.life = 1;
                                //sleep(1);

                                break;
                        }
                if (snack.x[0] == food.X && snack.y[0] == food.Y) {
                        food.set = 0;
                        snack.node++;
                        score += 10;
                        for (i = snack.node - 1; i > 0; i--) {
                                snack.x[i] = snack.x[i - 1];
                                snack.y[i] = snack.y[i - 1];
                        }
                        judge();
                }
                if (snack.life == 0) {
                        ;
                        for (i = 0; i < snack.node; i++)
                                mvprintw(snack.y[i], snack.x[i], "*");
                        //attron(A_INVIS);

                        mvaddch(food.Y, food.X, '*');
                        //sleep(1);

                        //attroff(A_INVIS);

                        start_attr();
                        output();
                        nanosleep(&delay, &dummy); //sleep(2);

                }

                else {
                        char ch1;
                        while (ch1 = getch())
                                if (ch1 == 'y' || ch1 == 'Y') {
                                        clear();
                                        for (i = 0; i < snack.node; i++)
                                                snack.x[i] = snack.y[i] = -1;
                                        TIME = Time1 = Time2 = k = 0;
                                        score = 0;
                                        draw();
                                        snack.life = 0;
                                        break;
                                } else if (ch1 == 'n' || ch1 == 'N') {
                                        endwin();
                                        exit(1);
                                } else
                                        continue;
                }
        }
}


附一张程序运行图：



------------------------------------------------------------------------------------------------------------------------------

本文还需完善。



d4shman
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c语言实现的超简单贪吃蛇游戏
09-13
c语言实现的超简单贪吃蛇游戏
C语言，Linux，贪吃蛇游戏
weixin_43597971的博客
11-04 786
在Ubuntu的Linux系统上，做贪吃蛇游戏，也是对C语言的应用总结！
运用C在Linux系统中写贪吃蛇小游戏
weixin_55179981的博客
09-09 3231
贪吃蛇编写
贪吃蛇小项目C语言版（基于LINUX操作系统下）
qq_53918454的博客
10-28 2230
1.首先，制作一个游戏地图——一个大的矩形框，这里我是用的for循环来打印的，大家可能会想为什么不直接用printf()来打印，直接用printf()可以直观上得到地图，但是对后续操作极其不便，因为这是一个固定地图，不能动态变化，所以我们用for循环加上if-else if语句来动态打印地图（注意：要根据打印出来的地图的样子不断修改）。2.接下来就是贪吃蛇本身了，游戏中贪吃蛇是由3个[]组成的，在地图中打印3个[]可以通过静态链表和动态链表来完成，毫无疑问我们要选择动态链表。
在Linux下用C语言写贪吃蛇；
qq_47944751的博客
09-21 1620
贪吃蛇的编写
Linux下贪吃蛇的c语言实现
weixin_53762042的博客
12-18 1696
#include<curses.h> #include<stdlib.h> #include<pthread.h> #include<unistd.h> #define UP 1 #define DOWN -1 #define LEFT 2 #define RIGHT -2 struct Snake{ int hang; int lie; struct Snake*next; };//声明贪吃蛇结点的结构体 struct Snake*head=NU
C语言学习笔记.docx
12-16
C语言学习笔记.docx
C语言学习笔记.doc
11-29
C语言学习笔记.doc
C语言学习笔记
08-04
根据自学书本+视频教程过程记录的笔记，希望能有所帮助~
c语言学习笔记.pdf
11-16
c语言学习笔记.pdf
Linux下C语言版本的贪吃蛇游戏源码
12-03
利用Linux终端图形库curses编写的贪吃蛇小游戏，平台语言是C。
Linux下纯C的贪吃蛇
09-05
这个程序是Linux下的纯C语言开发的一款贪吃蛇软件，下载后直接运行snake.sh(./snake.sh)即可，（如果没有权限可以用chmod 777 snake.sh加上权限）。 如果还有其他的疑问可以随时给我留言，我会尽我所能的解答亲的问题。
[源码] Linux C 贪吃蛇
08-18
Linux 下用C语言写的贪吃蛇 用到了 pthread 和curses 用gcc -lpthread -lcurses 编译
linux平台c语言实现贪吃蛇小游戏
03-09
编译命令 gcc snake.c -lncurses -lpthread
基于c语言在linux下贪吃蛇项目
12-29
在Linux虚拟机下用c语言写的一个贪吃蛇游戏项目，源于一个游戏教学开发项目工程，可下载运行提供学习借鉴，供有C语言基础和linux基础的学习，有界面化制作，算法的编写。
C语言实现贪吃蛇游戏（Linux下实现）
qq_43660337的博客
03-11 8216
文章目录一、ncurse图形库二、思路步骤1.准备工作2.考虑如何输出图形界面3.考虑蛇是如何移动的4.实现页面刷新5.判断键盘输入6.Liunx线程解决键入值和界面并行问题三、完整代码四、总结 一、ncurse图形库 ncurses(new curses)是一套编程库，它提供了一系列的函数以便使用者调用它们去生成基于文本的用户界面。贪吃蛇游戏就选用这种简单的图形库来显示。 以下使贪吃蛇项目中用到的一些ncurses库中的函数（代码如下）： #include<curses.h> // L
linux-c语言练手——贪吃蛇小游戏
SCT_CX的博客
02-08 471
贪吃蛇
用C语言实现贪吃蛇（基于Linux系统 ubuntu 环境，调用curses库实现）
m0_72442663的博客
03-04 772
基于C语言 ，linux 系统，实现贪吃蛇小游戏。
linuxC下的贪吃蛇游戏
03-30
编译的时候记得把两个".c"文件一起编译了，然后运行，当然代码有改进的地方，这个用的时候自己改进一下啦
c语言学习笔记 薛小龙pdf
最新发布
08-30
《c语言学习笔记薛小龙pdf》是一本关于C语言学习的教材或笔记，作者是薛小龙。 C语言是一种通用的编程语言，广泛应用于各个领域的软件开发中。学习C语言对于计算机科学和软件工程学生来说非常重要，因为它是他们进阶学习更多高级编程语言的基础。 薛小龙编写的这本《c语言学习笔记薛小龙pdf》可能包含了C语言的基础知识和必要的编程技巧。学习此书，读者可以了解到C语言的语法、变量、数据类型、运算符、控制结构等基础知识，以及函数、指针、数组等更高级的概念和技术。 学习C语言有助于培养编程思维和解决问题的能力。通过编写简单的程序，读者可以理解计算机程序的运行原理，掌握算法和数据结构的基本知识，提高程序设计和调试的能力。 对于初学者来说，《c语言学习笔记薛小龙pdf》可能是一个很好的学习资源。由于它是以笔记的形式编写的，可能会更具有条理性和易于理解。读者可以按照自己的学习进度和需求，逐步学习书中的内容，通过实践编程来巩固所学知识。 总而言之，薛小龙编写的《c语言学习笔记薛小龙pdf》对于想学习C语言的人来说是一本宝贵的资源。通过阅读、理解和实践书中的内容，读者可以掌握C语言的基础知识和编程技巧，从而打下良好的编程基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值