C语言——贪吃蛇小游戏

已于 2023-09-17 18:24:34 修改
阅读量6.4k 收藏 96
点赞数 35
分类专栏： C语言 文章标签： c语言 开发语言
于 2023-09-17 18:08:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54859557/article/details/132948307
版权

目录

一、ncurse

1.1 为什么需要用ncurse：

1.2 ncurse的输入输出：

1.2.1 如何使用ncurse：

1.2.2 编译ncurse的程序：

1.2.3 测试输入一个按键ncurse的响应速度：

1.3 ncurse上下左右键获取：

1.3.1 如何查看宏定义的.h文件：

1.3.2 ncurse上下左右键获取：

二、地图规划

2.1 地图规划算法显示第一行：

2.2 实现贪吃蛇完整地图：

2.3 优化贪吃蛇地图：

三、显示贪吃蛇身子

3.1 显示贪吃蛇身子的一个节点：

3.2 显示贪吃蛇完整身子：

3.3 显示贪吃蛇完整身子改进：

四、贪吃蛇移动

4.1 按下▶贪吃蛇向右移动：

4.2 贪吃蛇撞墙重新开始： 

4.3 贪吃蛇脱缰自由向右行走

五、Linux线程引入

5.1 贪吃蛇方向移动和刷新界面一起实现面临的问题：

5.2 线程的基本用法：

5.3 线程demo案例：

5.4 使用线程解决贪吃蛇方向移动和刷新界面一起实现面临的问题：

六、贪吃蛇跑起来

6.1 实现贪吃蛇四方向的风骚走位：

6.2 用绝对值方式来解决不合理的走位：

6.3 贪吃蛇吃饭了（食物的位置是随机的）：

七、项目代码

  • 项目运行环境：Linux，基于Ncurse图形库的C语言小游戏

  • 项目的目的和意义：起到承上启下的作用，对于前面学的C语言的基础和数据结构链表做一个比较好的巩固，对于后面的Linux系统编程的开发做铺垫

  • 项目基础要求：C语言基础、Linux基本操作

    /*项目步骤*/
（1）选择ncurses库的原因
在进行贪吃蛇游戏时，贪吃蛇的行进方向需要你按下上下左右键进行操控，如果使用C语言自带的函数，例如：scanf或者getchar之类的，需要你按下回车键，程序才能进行响应，而这显然是十分不方便的，但是ncurses库就很好的解决了这个问题。ncurses库自带的函数getch就能实现迅速便捷的贪吃蛇方向响应。

（2）ncurses库的基本入门
对于该项目而言，ncurses库我们不需要进行过于深入的学习，只需要知道一些基本的函数使用即可。下列程序中的函数，就是一个基于ncurses库的基本代码框架。
#include <curses.h>
 
int main()
{
        initscr();//ncurse界面的初始化函数
        printw("this is a curses window\n");//在ncurse模式下的printf
        getch();//等待用户的输入，如果没有这句话，程序就退出了，看不到运行的结果，也就是无法看到上面那句话
        endwin();//程序退出，恢复shell终端的显示，如果没有这句话，shell终端字乱码，坏掉
 
        return 0;
}

（3）贪吃蛇地图的整体规划
整个贪吃蛇地图的大小将它设置成一个20*20的近似正方形，使用"|"来表示左右边框，使用"--"来表示上下边框。

（4）实现贪吃蛇第一个节点的显示
    
（5）显示贪吃蛇的完整身子
注意，在这里，我们设置两个全局变量，struct Snake *head和struct Snake *tail，一个指向贪吃蛇的头，一个指向贪吃蛇的尾。在将第一个节点打印完后，将尾指向头，即：head = tail。每一次节点的添加，我们调用一个单独的函数去执行，并其使用尾插法实现。

（6）实现贪吃蛇的右移
贪吃蛇的移动，整体来说就是链表节点的删除与添加。我们首先实现贪吃蛇的右移，每当按键按下时，贪吃蛇右移一格，即左侧的头结点删除head = head->next，右侧再次添加一个新的节点。新节点的坐标应该是行不变，列加一。注意：不要忘记清楚垃圾节点。

（7）实现贪吃蛇的撞墙死亡
将贪吃蛇的尾节点坐标进行判断，判断其是否达到边界坐标。满足条件时，将贪吃蛇重新初始化。注意：不要忘记清楚垃圾节点。

（8）实现贪吃蛇的自由行走
在这里，我们发现了一个问题，地图需要实时刷新进行贪吃蛇位置的变更，这是一个while(1)的死循环，而获取键值也是一个实时读取的操作，因此也是一个while(1)死循环，代码执行逻辑上出现了问题，所以我们引入了线程的概念。

（9）了解什么是线程
    
（10）用线程解决上述问题，实现贪吃蛇的分骚走位
开辟两个线程，一个用来执行地图刷新操作，一个用来获取键值。
 pthread_create(&t1,NULL,refreshScreen,NULL);
 pthread_create(&t2,NULL,changeDir,NULL);

（11）解决贪吃蛇的不合理走位
在这里，我们使用绝对值法来解决问题，abs函数的作用便是取绝对值，我们将上下左右键，两两对应，宏定义为1，-1,2，-2之类的数就能成功解决问题。

（12）实现贪吃蛇食物的打印
    
（13）实现食物的随机出现
取随机数，C语言有一个自带的函数可以解决这个问题，rand()函数可以实现随机取数，我们只要再对它进行取余操作，便可以防止食物出现在地图以外的位置。

（14）实现贪吃蛇咬到自己结束游戏，重新开始的操作
当贪吃蛇的尾节点与自身除尾巴节点以外的其他节点进行比较后，若行列数相同，则初始化整个贪吃蛇，注意：不要忘记垃圾节点的清除（我们可以在每次贪吃蛇初始化之前进行这个操作）。

    一、ncurse

    1.1 为什么需要用ncurse：

  • 因为的按键响应牛逼哄哄

  • 1.2 ncurse的输入输出：

  • ncurse用的最多的地方是在Linux内核编译之前的内核配置

  • 1.2.1 如何使用ncurse：

1.2.2 编译ncurse的程序：

1.2.3 测试输入一个按键ncurse的响应速度：
1 #include <curses.h>
  2 
  3 int main()
  4 {
  5         char c;
  6 
  7         initscr();
  8         c = getch();
  9         printw("you Input :%c\n",c);
 10         getch();
 11         endwin();
 12         return 0;
 13 }

  • 使用ncurse的好处是：按下一个按键不需要按下回车，直接就可以输出c的值，和我们C语言的其他输入函数好用

1.3 ncurse上下左右键获取：

1.3.1 如何查看宏定义的.h文件：

vi /usr/include/curses.h    //查看宏定义.h文件的指令
:q                            //退出查看

1.3.2 ncurse上下左右键获取：

 1 #include <curses.h>
  2 
  3 int main()
  4 {
  5         int key;
  6 
  7         initscr();
  8         keypad(stdscr,1);	//这个函数允许使用功能键，例如：F1、F2、方向键等功能键。几乎所有的交互式程序都需要使用功能			键，因为绝大多数用户界面主要用方向键进行操作。使用keypad(stdscr,TURE)就为“标准屏幕”（stdscr）激活了功能键。
  9 
 10         while(1){
 11                 key = getch();
 12                 switch(key){
 13                         case KEY_DOWN:
 14                                 printw("DOWN\n");
 15                                 break;
 16                         case KEY_UP:
 17                                 printw("up\n");
 18                                 break;
 19                         case KEY_LEFT:
 20                                 printw("LEFT\n");
 21                                 break;
 22                         case KEY_RIGHT:
 23                                 printw("RIGHT\n");
 24                                 break;
 25                 }
 26 
 27 
 28         }
 29         endwin();
 30         return 0;
 31 }

  • 我们按下上下左右▲▼◀▶之后，可以获取到上下左右的打印信息

二、地图规划

2.1 地图规划算法显示第一行：

#include <curses.h>

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

void gamPic()
{
	int hang;
	int lie;
	
	for(hang=0; hang<20; hang++){
		if(hang == 0){
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			for(lie=0; lie<=20; lie++){
				if(lie == 0 || lie == 20){
					printw("|");
				}else{
					printw("  ");
				}
			}
		}
	}
}

int main()
{
	initNcurse();	//初始化Ncurse
	gamPic();		//地图规划显示第一行
	
	getch();
	endwin();
	return 0;
}

2.2 实现贪吃蛇完整地图：

#include <curses.h>

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

void gamPic()
{
	int hang;
	int lie;
	
	for(hang=0; hang<20; hang++){
		if(hang == 0){
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			for(lie=0; lie<=20; lie++){
				if(lie == 0 || lie == 20){
					printw("|");
				}else{
					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 ShiYaHao!\n");
		}
	}
}

int main()
{
	initNcurse();	//初始化Ncurse
	gamPic();		//实现贪吃蛇地图
	
	getch();
	endwin();
	return 0;
}

2.3 优化贪吃蛇地图：

#include <curses.h>

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

void gamPic()
{
	int hang;
	int lie;
	
	for(hang=0; hang<20; hang++){
		if(hang == 0){						//第0行打“--”
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
		}
		
		if(hang>=0 && hang<=19) {			//第0行-19行的第0列和第20列打“|”
			for(lie=0; lie<=20; lie++){
				if(lie == 0 || lie == 20){
					printw("|");
				}else{
					printw("  ");
				}
			}
			printw("\n");
		}

		if(hang == 19){						//第19行打“--”
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			printw("By ShiYaHao!\n");		//作者
		}
	}
}

int main()
{
	initNcurse();
	gamPic();
	
	getch();
	endwin();
	return 0;
}
//实现的贪吃蛇地图和上面一样，只不过是优化了一下代码

三、显示贪吃蛇身子

3.1 显示贪吃蛇身子的一个节点：

#include <curses.h>

struct Snake
{
	int hang;
	int lie;
	struct Snake *next;
};

struct Snake node1 = {2,2,NULL};

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

void gamPic()
{
	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 if(node1.hang == hang && node1.lie == lie){
					printw("[]");
				}else{
					printw("  ");
				}
			}
			printw("\n");
		}

		if(hang == 19){
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			printw("By ShiYaHao!\n");
		}
	}
}

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

3.2 显示贪吃蛇完整身子：

#include <curses.h>

struct Snake
{
	int hang;
	int lie;
	struct Snake *next;
};

struct Snake node1 = {2,2,NULL};
struct Snake node2 = {2,3,NULL};
struct Snake node3 = {2,4,NULL};
struct Snake node4 = {2,5,NULL};

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

int hasSnakeNode(int i, int j)
{
	struct Snake *p = &node1;

	while(p != NULL){
		if(p->hang == i && p->lie == j){
			return 1;
		}
		p = p->next;
	}
	return 0;
}

void gamPic()
{
	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 if(hasSnakeNode(hang,lie)){
					printw("[]");
				}else{
					printw("  ");
				}
			}
			printw("\n");
		}

		if(hang == 19){
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			printw("By ShiYaHao!\n");
		}
	}
}

int main()
{
	initNcurse();

	node1.next = &node2;
	node2.next = &node3;
	node3.next = &node4;

	gamPic();
	
	getch();
	endwin();
	return 0;
}

3.3 显示贪吃蛇完整身子改进：

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

struct Snake
{
	int hang;
	int lie;
	struct Snake *next;
};

struct Snake *head = NULL;	//指向链表头
struct Snake *tail = NULL;	//指向链表尾

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

int hasSnakeNode(int i, int j)
{
	struct Snake *p = head;

	while(p != NULL){
		if(p->hang == i && p->lie == j){
			return 1;
		}
		p = p->next;
	}
	return 0;
}

void gamPic()				//地图规划
{
	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 if(hasSnakeNode(hang,lie)){
					printw("[]");
				}else{
					printw("  ");
				}
			}
			printw("\n");
		}

		if(hang == 19){
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			printw("By ShiYaHao!\n");
		}
	}
}

void addNode()
{
	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));	//创建新节点
	if(new == NULL){
		printw("malloc error\n");
	}
	new->hang = tail->hang;		//新节点的行等于链表尾的行
	new->lie  = tail->lie+1;	//新节点的行等于链表尾的列+1
	new->next = NULL;

	tail->next = new;			//从链表尾部插入新节点
	tail = new;					//新节点当作尾部
}

void initSnake()
{
	head = (struct Snake *)malloc(sizeof(struct Snake));	//创建链表头
	if(head == NULL){
		printw("malloc error\n");
	}
	head->hang = 2;			
	head->lie = 2;
	head->next = NULL;

	tail = head;		//第一个节点链表头和链表尾是一样的

	addNode();			//调用一次代表增加一个节点
	addNode();
	addNode();
}

int main()
{
	initNcurse();
	
	initSnake();

	gamPic();
	
	getch();
	endwin();
	return 0;
}

四、贪吃蛇移动

4.1 按下▶贪吃蛇向右移动：

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

struct Snake
{
	int hang;
	int lie;
	struct Snake *next;
};

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

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

int hasSnakeNode(int i, int j)
{
	struct Snake *p = head;

	while(p != NULL){
		if(p->hang == i && p->lie == j){
			return 1;
		}
		p = p->next;
	}
	return 0;
}

void gamPic()
{
	int hang;
	int lie;
	
	move(0,0);
		
	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 if(hasSnakeNode(hang,lie)){
					printw("[]");
				}else{
					printw("  ");
				}
			}
			printw("\n");
		}

		if(hang == 19){
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			printw("By ShiYaHao!\n");
		}
	}
}

void addNode()
{
	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));
	
	new->hang = tail->hang;
	new->lie  = tail->lie+1;
	new->next = NULL;

	tail->next = new;
	tail = new;
}

void initSnake()
{
	head = (struct Snake *)malloc(sizeof(struct Snake));
	if(head == NULL){
		printw("malloc error\n");
	}
	head->hang = 2;
	head->lie = 2;
	head->next = NULL;

	tail = head;

	addNode();
	addNode();
	addNode();
	addNode();
}

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

void moveSnake()
{
	addNode();		//增加一个节点
	deletNode();	//删除头节点
}

int main()
{
	int con;

	initNcurse();
	initSnake();

	gamPic();
	
	while(1){
		con = getch();			//con获取键值
		if(con == KEY_RIGHT){	//如果是右键
			moveSnake();		//向右移动
			gamPic();			//必须刷新一下界面，否则看不到🐍移动
		}		
	}
	getch();
	endwin();
	return 0;
 }

4.2 贪吃蛇撞墙重新开始： 

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

struct Snake
{
	int hang;
	int lie;
	struct Snake *next;
};

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

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

int hasSnakeNode(int i, int j)
{
	struct Snake *p = head;

	while(p != NULL){
		if(p->hang == i && p->lie == j){
			return 1;
		}
		p = p->next;
	}
	return 0;
}

void gamPic()
{
	int hang;
	int lie;
	
	move(0,0);
		
	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 if(hasSnakeNode(hang,lie)){
					printw("[]");
				}else{
					printw("  ");
				}
			}
			printw("\n");
		}

		if(hang == 19){
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			printw("By ShiYaHao!\n");
		}
	}
}

void addNode()
{
	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));
	if(new == NULL){
		printw("malloc error\n");
	}
	new->hang = tail->hang;
	new->lie  = tail->lie+1;
	new->next = NULL;

	tail->next = new;
	tail = new;
}

void initSnake()
{
	struct Snake *p;
	while(head != NULL){	判断蛇是否为空，清理内存 
		p = head;
		head = head->next;
		free(p);
	}

	head = (struct Snake *)malloc(sizeof(struct Snake));
	if(head == NULL){
		printw("malloc error\n");
	}
	head->hang = 1;
	head->lie = 1;
	head->next = NULL;

	tail = head;

	addNode();
	addNode();
	addNode();
	addNode();
}

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

void moveSnake()
{
	addNode();
	deletNode();
	
    //判断蛇的尾巴碰到上下左右的四个边框后就重新开始
	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
		initSnake();
	}
}

int main()
{
	int con;

	initNcurse();
	initSnake();

	gamPic();
	
	while(1){
		con = getch();
		if(con == KEY_RIGHT){
			moveSnake();
			gamPic();
		}		
	}
	getch();
	endwin();
	return 0;
 }

4.3 贪吃蛇脱缰自由向右行走

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

struct Snake
{
	int hang;
	int lie;
	struct Snake *next;
};

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

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

int hasSnakeNode(int i, int j)
{
	struct Snake *p = head;

	while(p != NULL){
		if(p->hang == i && p->lie == j){
			return 1;
		}
		p = p->next;
	}
	return 0;
}

void gamPic()
{
	int hang;
	int lie;
	
	move(0,0);
		
	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 if(hasSnakeNode(hang,lie)){
					printw("[]");
				}else{
					printw("  ");
				}
			}
			printw("\n");
		}

		if(hang == 19){
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			printw("By ShiYaHao!\n");
		}
	}
}

void addNode()
{
	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));
	if(new == NULL){
		printw("malloc error\n");
	}
	new->hang = tail->hang;
	new->lie  = tail->lie+1;
	new->next = NULL;

	tail->next = new;
	tail = new;
}

void initSnake()
{
	struct Snake *p;
	while(head != NULL){
		p = head;
		head = head->next;
		free(p);
	}

	head = (struct Snake *)malloc(sizeof(struct Snake));
	if(head == NULL){
		printw("malloc error\n");
	}
	head->hang = 1;
	head->lie = 1;
	head->next = NULL;

	tail = head;

	addNode();
	addNode();
	addNode();
	addNode();
}

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

void moveSnake()
{
	addNode();
	deletNode();

	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
		initSnake();
	}
}

int main()
{
	int con;

	initNcurse();
	initSnake();

	gamPic();
	
	while(1){	//之前受方向键控制，现在自由行走
			moveSnake();	
			gamPic();	
			refresh();			//刷新界面
			usleep(100000);		//延时100ms
	}
	getch();
	endwin();
	return 0;
 }

五、Linux线程引入

5.1 贪吃蛇方向移动和刷新界面一起实现面临的问题：

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

struct Snake
{
	int hang;
	int lie;
	struct Snake *next;
};

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

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

int hasSnakeNode(int i, int j)
{
	struct Snake *p = head;

	while(p != NULL){
		if(p->hang == i && p->lie == j){
			return 1;
		}
		p = p->next;
	}
	return 0;
}

void gamPic()
{
	int hang;
	int lie;
	
	move(0,0);
		
	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 if(hasSnakeNode(hang,lie)){
					printw("[]");
				}else{
					printw("  ");
				}
			}
			printw("\n");
		}

		if(hang == 19){
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			printw("By ShiYaHao!\n");
		}
	}
}

void addNode()
{
	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));
	if(new == NULL){
		printw("malloc error\n");
	}
	new->hang = tail->hang;
	new->lie  = tail->lie+1;
	new->next = NULL;

	tail->next = new;
	tail = new;
}

void initSnake()
{
	struct Snake *p;
	while(head != NULL){
		p = head;
		head = head->next;
		free(p);
	}

	head = (struct Snake *)malloc(sizeof(struct Snake));
	if(head == NULL){
		printw("malloc error\n");
	}
	head->hang = 1;
	head->lie = 1;
	head->next = NULL;

	tail = head;

	addNode();
	addNode();
	addNode();
	addNode();
}

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

void moveSnake()
{
	addNode();
	deletNode();

	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
		initSnake();
	}
}

int main()
{
	int key;

	initNcurse();
	initSnake();

	gamPic();
	
	while(1){
			moveSnake();
			gamPic();
			refresh();
			usleep(100000);
	}
	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;
		}
	}	
	getch();
	endwin();
	return 0;
 }

  • 在上面的程序中main函数中有两个while(1)循环,这样就会出现问题，程序运行的现象是：获取按键值的这个while循环根本不会执行，那该如何解决？于是引入“Linux线程”！

  • 在贪吃蛇运动过程中，我们需要改变蛇的移动方向，这是就需要不停扫描键盘输入的值来判断方向，同时还需要不停的刷新界面，为了多个while循环并存这里需要引入linux线程。

5.2 线程的基本用法：

#include <pthread.h>  // 头文件

pthread_t：当前Linux中可理解为：typedef  unsigned long int  pthread_t;
如：pthread_t t1;  //多线程定义

pthread_create(&t1,NULL,refreshInterface,NULL); 
参数1：传出参数，保存系统为我们分配好的线程ID
参数2：通常传NULL，表示使用线程默认属性。若想使用具体属性也可以修改该参数。
参数3：函数指针，指向线程主函数(线程体)，该函数运行结束，则线程结束。
参数4：线程主函数执行期间所使用的参数，如要传多个参数, 可以用结构封装。

使用多线程的函数必须返回指针型，如void *refreshInterface()

注：gcc xxx.c -lcurses -lpthead  //编译需要连接pthead库

5.3 线程demo案例：

/*
	在这个程序当中只有func1一个函数会被执行,func2函数根本不会执行
	想要解决这个问题就需要引入Linux的线程
*/
#include <stdio.h>

void pfunc1()
{
    while(1){
         printf("this is a pfunc1\n");
       	 sleep(1);
    } 
}

void pfunc2()
{
    while(1){
         printf("this is a pfunc2\n");
       	 sleep(1);
    } 
}

int main()
{
    pfunc1();
    pfunc2();
    return 0;
}
/*
	引入Linux线程修改代码，func1和func2两个函数都可以执行
*/
#include <stdio.h>
#include <pthread.h>	//线程头文件

void* func1()
{
	while(1){

		printf("this is a func1\n");
		sleep(1);
	}
	
}

void* func2()
{
	while(1){

		printf("this is a func2\n");
		sleep(1);
	}
}

int main()
{
	pthread_t th1;	//定义一个th1线程
	pthread_t th2;	//定义一个th2线程

	pthread_create(&th1, NULL, func1, NULL);
	pthread_create(&th2, NULL, func2, NULL);
	while(1);
	return 0;
}

5.4 使用线程解决贪吃蛇方向移动和刷新界面一起实现面临的问题：

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

struct Snake
{
	int hang;
	int lie;
	struct Snake *next;
};

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

int key;

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

int hasSnakeNode(int i, int j)
{
	struct Snake *p = head;

	while(p != NULL){
		if(p->hang == i && p->lie == j){
			return 1;
		}
		p = p->next;
	}
	return 0;
}

void gamPic()
{
	int hang;
	int lie;
	
	move(0,0);
		
	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 if(hasSnakeNode(hang,lie)){
					printw("[]");
				}else{
					printw("  ");
				}
			}
			printw("\n");
		}

		if(hang == 19){
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			printw("By ShiYaHao!key = %d\n",key);
		}
	}
}

void addNode()
{
	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));

	new->hang = tail->hang;
	new->lie  = tail->lie+1;
	new->next = NULL;

	tail->next = new;
	tail = new;
}

void initSnake()
{
	struct Snake *p;
	while(head != NULL){
		p = head;
		head = head->next;
		free(p);
	}

	head = (struct Snake *)malloc(sizeof(struct Snake));

	head->hang = 1;
	head->lie = 1;
	head->next = NULL;

	tail = head;

	addNode();
	addNode();
	addNode();
	addNode();
}

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

void moveSnake()
{
	addNode();
	deletNode();

	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
		initSnake();
	}
}

void* refreshJieMian()
{
	
	while(1){
			moveSnake();
			gamPic();
			refresh();
			usleep(100000);
	}
}

void* changeDir()
{
	
	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();
	
    //注意：线程创建要放在初始化后面，不然就会导致程序段错误(答疑老师解决)
	pthread_t t1;
	pthread_t t2;
	pthread_create(&t1, NULL, refreshJieMian, NULL);
	pthread_create(&t2, NULL, changeDir, NULL);

	gamPic();
	
	while(1);
	getch();
	endwin();
	return 0;
 }

  • 蛇在向右移动的同时也可以按方向键，这就是引入线程之后的牛逼之处！

六、贪吃蛇跑起来

6.1 实现贪吃蛇四方向的风骚走位：
#include <curses.h>
#include <stdlib.h>
#include <pthread.h>

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

struct Snake
{
	int hang;
	int lie;
	struct Snake *next;
};

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

int key;
int dir;

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

int hasSnakeNode(int i, int j)
{
	struct Snake *p = head;

	while(p != NULL){
		if(p->hang == i && p->lie == j){
			return 1;
		}
		p = p->next;
	}
	return 0;
}

void gamPic()
{
	int hang;
	int lie;
	
	move(0,0);
		
	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 if(hasSnakeNode(hang,lie)){
					printw("[]");：
				}else{
					printw("  ");
				}
			}
			printw("\n");
		}

		if(hang == 19){
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			printw("By ShiYaHao!key = %d\n",key);
		}
	}
}

void addNode()
{
	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));

	new->hang = tail->hang;
	new->lie  = tail->lie+1;
	new->next = NULL;

	switch(dir){
		case UP:	
      		new->hang = tail->hang-1;
			new->lie  = tail->lie;
			break;
		case DOWN:	
      		new->hang = tail->hang+1;
			new->lie  = tail->lie;
			break;
		case LEFT:	
      		new->hang = tail->hang;
			new->lie  = tail->lie-1;
			break;
		case RIGHT:	
      		new->hang = tail->hang;
			new->lie  = tail->lie+1;
			break;
	}

	tail->next = new;
	tail = new;
}

void initSnake()
{
	struct Snake *p;

	dir = RIGHT;
	
	while(head != NULL){
		p = head;
		head = head->next;
		free(p);
	}

	head = (struct Snake *)malloc(sizeof(struct Snake));

	head->hang = 1;
	head->lie = 1;
	head->next = NULL;

	tail = head;

	addNode();
	addNode();
	addNode();
	addNode();
}

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

void moveSnake()
{
	addNode();
	deletNode();

	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
		initSnake();
	}
}

void* refreshJieMian()
{
	
	while(1){
			moveSnake();
			gamPic();
			refresh();
			usleep(100000);
	}
}

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

int main()
{
	pthread_t t1;
	pthread_t t2;

	initNcurse();
	initSnake();

	gamPic();

	pthread_create(&t1, NULL, refreshJieMian, NULL);
	pthread_create(&t2, NULL, changeDir, NULL);

	
	while(1);
	getch();
	endwin();
	return 0;
 }

6.2 用绝对值方式来解决不合理的走位：

#include <curses.h>
#include <stdlib.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 = NULL;
struct Snake *tail = NULL;

int key;
int dir;

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

int hasSnakeNode(int i, int j)
{
	struct Snake *p = head;

	while(p != NULL){
		if(p->hang == i && p->lie == j){
			return 1;
		}
		p = p->next;
	}
	return 0;
}

void gamPic()
{
	int hang;
	int lie;
	
	move(0,0);
		
	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 if(hasSnakeNode(hang,lie)){
					printw("[]");
				}else{
					printw("  ");
				}
			}
			printw("\n");
		}

		if(hang == 19){
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			printw("By ShiYaHao!key = %d\n",key);
		}
	}
}

void addNode()
{
	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));

	new->hang = tail->hang;
	new->lie  = tail->lie+1;
	new->next = NULL;

	switch(dir){
		case UP:	
      			new->hang = tail->hang-1;
			new->lie  = tail->lie;
			break;
		case DOWN:	
      			new->hang = tail->hang+1;
			new->lie  = tail->lie;
			break;
		case LEFT:	
      			new->hang = tail->hang;
			new->lie  = tail->lie-1;
			break;
		case RIGHT:	
      			new->hang = tail->hang;
			new->lie  = tail->lie+1;
			break;
	}

	tail->next = new;
	tail = new;
}

void initSnake()
{
	struct Snake *p;

	dir = RIGHT;
	
	while(head != NULL){
		p = head;
		head = head->next;
		free(p);
	}

	head = (struct Snake *)malloc(sizeof(struct Snake));

	head->hang = 1;
	head->lie = 1;
	head->next = NULL;

	tail = head;

	addNode();
	addNode();
	addNode();
	addNode();
}

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

void moveSnake()
{
	addNode();
	deletNode();

	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
		initSnake();
	}
}

void refreshJieMian()
{
	
	while(1){
			moveSnake();
			gamPic();
			refresh();
			usleep(100000);
	}
}

void turn(int direction)			通过绝对值判断相反方向不触发
{
	if(abs(dir) != abs(direction)){
		dir = direction;
	}
}

void changeDir()
{
	
	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()
{
	pthread_t t1;
	pthread_t t2;

	initNcurse();
	initSnake();

	gamPic();

	pthread_create(&t1, NULL, refreshJieMian, NULL);
	pthread_create(&t2, NULL, changeDir, NULL);

	
	while(1);
	getch();
	endwin();
	return 0;
 }

6.3 贪吃蛇吃饭了（食物的位置是随机的）：

#include <curses.h>
#include <stdlib.h>
#include <pthread.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 = NULL;
struct Snake *tail = NULL;

int key;
int dir;

struct Snake food;

void initFood()
{
	int x = rand()%20;
	int y = rand()%20;

	food.hang = x;
	food.lie  = y;
}

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

int hasSnakeNode(int i, int j)
{
	struct Snake *p = head;

	while(p != NULL){
		if(p->hang == i && p->lie == j){
			return 1;
		}
		p = p->next;
	}
	return 0;
}

int hasFood(int i, int j)
{
	if(food.hang == i && food.lie == j){
		return 1;
	}
	return 0;
}

void gamPic()
{
	int hang;
	int lie;
	
	move(0,0);
		
	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 if(hasSnakeNode(hang,lie)){
					printw("[]");
				}else if(hasFood(hang,lie)){
					printw("##");
				}else{
					printw("  ");
				}
			}
			printw("\n");
		}

		if(hang == 19){
			for(lie=0; lie<20; lie++){
				printw("--");
			}
			printw("\n");
			printw("By ShiYaHao! food.hang = %d,food.lie = %d\n",food.hang,food.lie);
		}
	}
}

void addNode()
{
	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));

	new->hang = tail->hang;
	new->lie  = tail->lie+1;
	new->next = NULL;

	switch(dir){
		case UP:	
      			new->hang = tail->hang-1;
			new->lie  = tail->lie;
			break;
		case DOWN:	
      			new->hang = tail->hang+1;
			new->lie  = tail->lie;
			break;
		case LEFT:	
      			new->hang = tail->hang;
			new->lie  = tail->lie-1;
			break;
		case RIGHT:	
      			new->hang = tail->hang;
			new->lie  = tail->lie+1;
			break;
	}

	tail->next = new;
	tail = new;
}

void initSnake()
{
	struct Snake *p;

	dir = RIGHT;
	
	while(head != NULL){
		p = head;
		head = head->next;
		free(p);
	}
	initFood();
	head = (struct Snake *)malloc(sizeof(struct Snake));

	head->hang = 1;
	head->lie = 1;
	head->next = NULL;

	tail = head;

	addNode();
	addNode();
	addNode();
	addNode();
}

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

void moveSnake()
{
	addNode();
	if(hasFood(tail->hang,tail->lie)){
		initFood();
	}else{	
		deletNode();
	}

	if(tail->hang < 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
		initSnake();
	}
}

void* refreshJieMian()
{
	
	while(1){
			moveSnake();
			gamPic();
			refresh();
			usleep(100000);
	}
}

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

void* changeDir()
{
	
	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()
{
	pthread_t t1;
	pthread_t t2;

	initNcurse();
	initSnake();

	gamPic();

	pthread_create(&t1, NULL, refreshJieMian, NULL);
	pthread_create(&t2, 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
 
struct Snake{
	int hang;
	int lie;
	struct Snake *next;
};

struct Snake *head = NULL;
struct Snake *tail = NULL;
struct Snake food;
int key;
int dir;
 
void addNode();                   /*从尾部插入新节点*/

//void initNcurses();               /*ncurses库的初始化函数*/
//void gameMap();                   /*贪吃蛇地图的初始化*/
//int printSnakeNode(int i,int j);  /*在地图上打印贪吃蛇的节点*/
//void initSnake();                 /*初始化贪吃蛇*/

//void deletNode();                 /*删除头结点*/
//void moveSnake();                 /*实现贪吃蛇的移动*/
//void *refreshScreen();            /*线程实现图像刷新*/
//void *changeDir();                /*线程实现贪吃蛇方向的改变*/
//void turn(int direction);         /*防止出现不合理走位*/
//void creatFood();                 /*随机出现食物*/
//int hasFood(int i,int j);         /*打印食物*/
//int ifSnakeDie();                 /*判断贪吃蛇是否死亡*/

 
/*随机出现食物*/
void creatFood()
{
	int x = rand()%20;
	int y = rand()%19+1;
 
	food.hang = x;
	food.lie = y;
}
 
int hasFood(int i,int j)
{
	if(food.hang == i && food.lie == j){
		return 1;
	}
	return 0;
}
 
/*ncurses库的初始化函数*/
void initNcurses()
{
	initscr();//ncurse界面的初始化函数
	keypad(stdscr,1);//使用keypad函数，才可以使用键盘功能键
	noecho();//防止打印无关键值
}
 
/*贪吃蛇地图的初始化*/
void gameMap()
{
	int hang;
	int lie;
 
	move(0,0);//把光标的位置移到头，实现地图刷新时的覆盖
	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 if(printSnakeNode(hang,lie)){
					printw("[]");
				}else if(hasFood(hang,lie)){
					printw("##");
				}else{
					printw("  ");
				}
			}
			printw("\n");
		}
		if(hang == 19){
			for(lie=0;lie<20;lie++){
				printw("--");
			}
			printw("\n");
		}
	}
		printw("By ShiYaHao!,food.hang = %d,food.lie = %d\n",food.hang,food.lie);
}
 
/*在地图上打印贪吃蛇的节点*/
int printSnakeNode(int i,int j)
{
	struct Snake *p = head;
	while(p != NULL){
		if(p->hang == i && p->lie == j){
			return 1;
		}
		p = p->next;
	}
	return 0;
}
 
/*初始化贪吃蛇*/
void initSnake()
{	
	struct Snake *p = NULL;
	if(head != NULL){   //当贪吃蛇死亡后，把多余节点释放
		p = head;
		head = head->next;	
		free(p);
	}
	
	creatFood();
	dir = RIGHT;
 
	head = (struct Snake *)malloc(sizeof(struct Snake));
	head->hang = 1;
	head->lie = 1;
	head->next = NULL;
 
	tail = head;
	
	addNode();
	addNode();
	addNode();
}
 
/*从尾部插入新节点*/
void addNode()
{
	struct Snake *new = (struct Snake *)malloc(sizeof(struct Snake));
 
	switch(dir){
		case UP:
			new->hang = tail->hang-1;
			new->lie = tail->lie;
			break;
		case DOWN:
			new->hang = tail->hang+1;
			new->lie = tail->lie;
			break;
		case LEFT:
			new->hang = tail->hang;
			new->lie = tail->lie-1;
			break;
		case RIGHT:
			new->hang = tail->hang;
			new->lie = tail->lie+1;
			break;
	}
	new->next = NULL;
	tail->next = new;
	tail = new;
 
}
 
/*删除头结点*/
void deletNode()
{
	struct Snake *p = head;
	head = head->next;
	free(p);	
}
 
/*判断贪吃蛇是否死亡*/
int ifSnakeDie()
{
	struct Snake *p;
	p = head;
	if(tail->hang < 0 || tail->hang == 20 || tail->lie == 0 || tail->lie == 20){
		return 1;
	}
 
	while(p->next != NULL){
		if(p->hang == tail->hang && p->lie == tail->lie){
			return 1;
		}
		p = p->next;
	}
	return 0;
 
}
 
/*实现贪吃蛇的移动*/
void moveSnake()
{
	addNode();
	if(hasFood(tail->hang,tail->lie)){
		creatFood();
	}else{
		deletNode();
	}
 
	if(ifSnakeDie()){
		initSnake();
	}
 
}
 
/*线程实现图像刷新*/
void *refreshScreen()
{
	usleep(100000);
	while(1){
		moveSnake();
		gameMap();//刷新地图	
		refresh();//界面刷新函数
		usleep(100000);
	}
}
/*防止不合理走位*/
void turn(int direction)
{
	if(abs(dir) != abs(direction)){
		dir = direction;
	}
}
 
/*线程实现贪吃蛇方向的改变*/
void *changeDir()
{
	while(1){
		key = getch();
		switch(key){
			case KEY_UP:
				turn(UP);
				break;
			case KEY_DOWN:
				turn(DOWN);
				break;
			case KEY_LEFT:
				turn(LEFT);
				break;
			case KEY_RIGHT:
				turn(RIGHT);
				break;
		}
	}
}

int main()
{
	pthread_t t1;
	pthread_t t2;
 
	initNcurses();
	initSnake();
	gameMap();
 
	pthread_create(&t1,NULL,refreshScreen,NULL);
	pthread_create(&t2,NULL,changeDir,NULL);
 
	while(1);
	getch();//等待用户的输入，如果没有这句话，程序就退出了，看不到运行的结果，也就是无法看到上面那句话
	endwin();//程序退出，恢复shell终端的显示，如果没有这句话，shell终端字乱码，坏掉
 
	return 0;
}

大专生学编程
关注
  • 35
    点赞
  • 踩
  • 96
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现贪吃蛇小游戏-源码
06-27
综上所述，这个C语言实现的贪吃蛇小游戏展示了如何利用控制台环境、C语言基本语法、数据结构和游戏逻辑来创建一个简单但有趣的游戏。它对于初学者来说是一个很好的实践项目，可以帮助他们理解和掌握C语言编程的基础...
C语言课设——贪吃蛇.7z
02-07
贪吃蛇是一款经典的电子游戏，最早出现在早期的诺基亚手机上，后来逐渐成为各种平台上的热门小游戏。在C语言中实现贪吃蛇，可以帮助学习者深入理解基本的编程概念，如循环、条件判断、数组、函数以及内存管理等。...
贪吃蛇小游戏（C语言实现简易版）
weixin_42098648的博客
10-27 3260
大一作品，贪吃蛇小游戏具有菜单功能，难度选择功能，记录功能，暂停功能，缺陷在于不能将游戏分数存入文件中，游戏记录只在当次游戏时有效。
C语言实现贪吃蛇
qq_49723651的博客
05-13 1万+
C语言实现贪吃蛇 贪吃蛇项目是在b站的一位老师那里边学边敲的（现在视频被老师删掉了），在这里记录一下代码和学习时的一些思考，希望自己以后能用链表将贪吃蛇实现。 思考过程： 贪吃蛇 C语言实现 1.打印首页 --FirstPage() 功能：提示用户按下空格开始游戏。; 知识点：C语言中接受直接接受键盘的一个字符而不用按回车就开始执行下一步命令的函数：_getch()，在conio.ht头文件中。 2.清空屏幕 --TestSpace() 功能：用户按下空格以后清空首页。 知识点：利用system("
C语言:贪吃蛇
最新发布
2302_81053095的博客
04-27 1360
​ 贪吃蛇，一种很贪吃的蛇。 贪吃蛇是一款久负盛名的游戏，它也和俄罗斯方块，扫雷等游戏位列经典游戏的行列。 接下来，我们用500行代码实现这个游戏！ ​
C语言实现贪吃蛇（详细版）
m0_73906588的博客
05-12 3万+
以上就是贪吃蛇的基本内容啦，完结撒花~下面有一些想说的话：这篇文章的完成时间是2023.5.12，我现在是一名大一下的计科学生，其实C语言在去年十月份的中旬就看完了翁恺老师的网课，那个时候其实就有能力完成这个贪吃蛇的编写了，但是知道现在才写完，其实是走了很多弯路，耽误了不少时间北哥，在加入北哥的知识星球”编程指北“后才回正了自己的学习方向，也希望大家都能在正确的道路上越走越远~
C语言实现贪吃蛇[内附详细步骤]
如是牛
09-12 2万+
C语言实现一款经典的贪吃蛇小游戏
用C语言写贪吃蛇
c3872931的博客
07-16 3217
在黑色窗口，输入方向键。需要的C语言图形库以在。
c语言贪吃蛇
qq_74222589的博客
11-20 1753
c语言贪吃蛇
教你如何用C语言做一个简单的贪吃蛇
热门推荐
OMGMac的博客
06-02 3万+
小时候大家可能都玩过贪吃蛇，但有没有想过自己做一个出来玩玩看。今天我们就教大家用C语言做一个简单的贪吃蛇游戏。这里没有采用图形界面去做，而是采用win32控制台。 首先，先把做好的游戏初始界面和游戏截图先展示一下。
C语言实例——贪吃蛇
09-22
自己做的贪吃蛇小游戏，缺点就是没有窗体，希望大家喜欢
贪吃蛇游戏c语言
04-15
c语言的有界面能调速度
小程序——贪吃蛇
12-18
【小程序——贪吃蛇】是基于C语言实现的一款经典小游戏，它展示了编程初学者如何将基础知识应用于实际项目中。在C语言中，小程序通常是指利用基础语法和算法编写的小型程序，它们帮助开发者巩固概念，提升解决问题的...
C语言课程设计报告——贪吃蛇源程序.doc
07-25
C 语 言 课 程 设 计（小游戏贪吃蛇的程序设计报告） 目 录 一：概述 1：研究背景及意义 2：设计的任务与需要知识点 3：具体完成设计容 二：需求分析 1:功能需求 2:操作方法 三:总体设计 1:模块划分 2:数据结构...
贪吃蛇游戏--C语言版
weixin_46653651的博客
02-12 1546
C语言版贪吃蛇游戏
C语言项目实战——贪吃蛇游戏，附源码
qq_57263380的博客
02-01 6046
写一个较为基本的贪吃蛇游戏，附源码，亲测可用。
C语言编写贪吃蛇游戏
m0_53217058的博客
05-03 1208
C语言编写贪吃蛇游戏 ​ 完成了一下c语言入门完成的必修课——贪吃蛇游戏。边学边做也搞了一天，所以记录一下自己的学习过程吧！ 工具 ​ 因为我本来是用vscode进行编码的，发现不可以，查询才发现，vscode采用mingw，而制作图形界面的easyx使用的是支持的是vs的一些内容。 ​ 而我只是想制作贪吃蛇，对easyx没太多要求，能运行就行，加上安装vs2019并不复杂，并且需easyx装到vs2019里极其方变，下载然后打开，在install界面选择vs2019即可。就装了一个vs2019。 ​ 但使
C语言贴图贪吃蛇的制作
Luoyansu的博客
02-01 871
贪吃蛇2.0超详细制作（内含源码和图片音频）
C语言实战 - 贪吃蛇（图形界面）
good good study, day day up!
05-14 3408
C语言贪吃蛇
基于c语言的贪吃蛇小游戏
03-17
基于C语言的贪吃蛇小游戏是一种经典的控制台游戏，玩家通过控制蛇的移动来吃食物并不断增长身体长度，同时要避免蛇头碰到墙壁或自身身体。下面是一个简单的贪吃蛇游戏的实现思路： 1. 初始化游戏界面：使用二维数组表示游戏界面，其中0表示空白区域，1表示蛇身体，2表示食物，3表示墙壁。 2. 初始化蛇的位置和长度：将蛇的初始位置和长度存储在一个链表中。 3. 生成食物：随机生成一个坐标作为食物的位置，并将该位置的值设置为2。 4. 接收玩家输入：使用键盘监听函数获取玩家的输入方向（上、下、左、右）。 5. 更新蛇的位置：根据玩家的输入方向，更新蛇头的位置，并将新的位置添加到链表头部，同时删除链表尾部的节点。 6. 判断游戏结束条件：判断蛇头是否碰到墙壁或自身身体，如果是，则游戏结束。 7. 判断是否吃到食物：判断蛇头是否与食物位置重合，如果是，则增加蛇的长度，并生成新的食物。 8. 更新游戏界面：根据蛇的位置和食物的位置，更新游戏界面的二维数组。 9. 渲染游戏界面：根据二维数组的值，将游戏界面打印到控制台。 10. 循环执行步骤4-9，直到游戏结束。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值