贪吃蛇，自动找苹果吃（动态链表实现）（未做到完全躲避蛇身）理论上分数可刷到无限大

最新推荐文章于 2023-03-08 10:03:32 发布
最新推荐文章于 2023-03-08 10:03:32 发布
阅读量502 收藏 1
点赞数 1
文章标签： c语言 算法 链表 游戏 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Harari/article/details/103883354
版权

通过动态链表实现
自定义蛇身长度，速度，地图大小，规则

蛇自动吃苹果时：
无视蛇吃自己死亡规则分数可刷到无限大（蛇可叠加），加上蛇吃自己平均分15分左右
测试版，待改善
以下是演示效果

动态链表贪吃蛇，实现自动追踪食物，分可刷到无限大

规则控制内容

#define LEN 5//初始长度
int speed = 0;//初始速度
int autotexta = 1;//蛇吃后是否增长，1为增长
int autotextb = 0;//判定蛇吃自己开关，1为打开
/*刷测试模块（及游戏结束后立刻重新开始）*/
int texta = 1;//刷测试次数开关，1为开
int times = 100;//刷几次
int limit = 0;//得分最高限制，仅限于刷次数时有效,0为无限次
int pause = 0;//刷测试时结束暂停
/*自动控制模块*/
int autoall = 1;//自动控制总开关
int auto1 = 0;
int auto2 = 0;

移动蛇模块

void movesnake() {
	if (_kbhit()) {
		fflush(stdin);
		ch = _getch();
	}
	struct snake* lsd = tail;
	if (change) {
		gotoxy(lsd->x, lsd->y);
		color(blue);
		printf("■");
	}
	//	if (scor >= 1) {
	//		gotoxy(0, 0);
	//		color(blue);
	//		printf("□");
	//	}
	struct snake* lsa = lsd;
	struct snake* lsb = lsd->last;
	for (int i = len - 1; i > 0; i--) {
		lsa->x = lsb->x;
		lsa->y = lsb->y;
		lsa = lsa->last;
		lsb = lsb->last;
	}
	switch (ch) {
	case 'w':
	case 'W': {head->y--; break; }
	case'S':
	case's': {head->y++; break; }
	case'D':
	case'd': {head->x++; break; }
	case'a':
	case'A': {head->x--; break; }
	}
	gotoxy(head->x, head->y);
	color(yellow);
	printf("¤");
	struct snake* lsc = head->next;
	gotoxy(lsc->x, lsc->y);
	color(yellow);
	printf("★");
	change = 1;
	gotoxy(MAP, MAP-1);
}

控制蛇自动吃食物且保证蛇不碰壁或不吃自己函数
automove1为基础模块（必须）
automove2，3为带改善模块（可关掉），多次试验发现打开2与3后蛇吃自己平均分没有多大改善

void automove3() {
	struct snake* lsa = head->next;
	if (head->x - 1 == lsa->x && head->x + 1 == MAP)
		ch = 'w';
	if (head->x + 1 == lsa->x && head->x - 1 == 0)
		ch = 's';
	if (head->y + 1 == lsa->y && head->y - 1 == 0)
		ch = 'a';
	if (head->y - 1 == lsa->y && head->y + 1 == MAP)
		ch = 'd';
}
void automove2() {
	struct snake* lsa = head->next;
	struct snake* lsb = lsa->next;
	for (int i = 1; i < len - 2; i++) {
		if (head->x - 1 == lsa->x) {
			l = 0;
			if (head->x + 1 == lsb->x && head->y == lsb->y) {
				r = 0;
			}
			else r = 1;
			if (head->y - 1 == lsb->y && head->x == lsb->x) {
				u = 0;
			}
			else u = 1;
			if (head->y + 1 == lsb->y && head->x == lsb->x) {
				d = 0;
			}
			else d = 1;
			if (r == 0 || u == 0 || d == 0)
				break;
		}
		if (head->x + 1 == lsa->x) {
			r = 0;
			if (head->x - 1 == lsb->x && head->y == lsb->y) {
				l = 0;
			}
			else l = 1;
			if (head->y - 1 == lsb->y && head->x == lsb->x) {
				u = 0;
			}
			else u = 1;
			if (head->y + 1 == lsb->y && head->x == lsb->x) {
				d = 0;
			}
			else d = 1;
			if (l == 0 || u == 0 || d == 0)
				break;
		}
		if (head->y - 1 == lsa->y) {
			u = 0;
			if (head->x + 1 == lsb->x && head->y == lsb->y) {
				r = 0;
			}
			else r = 1;
			if (head->x - 1 == lsb->x && head->y == lsb->y) {
				l = 0;
			}
			else l = 1;
			if (head->y + 1 == lsb->y && head->x == lsb->x) {
				d = 0;
			}
			else d = 1;
			if (l == 0 || r == 0 || d == 0)
				break;
		}
		if (head->y + 1 == lsa->y) {
			d = 0;
			if (head->x + 1 == lsb->x && head->y == lsb->y) {
				r = 0;
			}
			else r = 1;
			if (head->x - 1 == lsb->x && head->y == lsb->y) {
				l = 0;
			}
			else l = 1;
			if (head->y - 1 == lsb->y && head->x == lsb->x) {
				u = 0;
			}
			else u = 1;
			if (l == 0 || r == 0 || u == 0)
				break;
		}
		lsb = lsb->next;
	}
	if (l == 0 && r == 0 && d == 0)
		ch = 'w';
	if (l == 0 && r == 0 && u == 0)
		ch = 's';
	if (r == 0 && u == 0 && d == 0)
		ch = 'a';
	if (l == 0 && u == 0 && d == 0)
		ch = 'd';
	//还有lrud其中有两个为0的情况，其中有八种情况

}
void automove1() {
	struct snake* lsa = head->next;
	if (head->x - 1 != lsa->x|| head->x + 1 != lsa->x) {
			if (head->y > appley&&u==1)
				ch = 'w';
			else if (head->y < appley&&d==1)
				ch = 's';
			
	}
	if (head->y - 1 != lsa->y || head->y + 1 != lsa->y) {
		if (head->x > applex&&l==1)
			ch = 'a';
		else if (head->x < applex&&r==1)
			ch = 'd';
	}
}
void automove() {
	automove1();
	if(auto1)
		automove2();
	if (auto2)
		automove3();
}

全文

#include<conio.h>
#include<stdlib.h>
#include<stdio.h>
#include<Windows.h>
#include<time.h>
#include<malloc.h>
#include<math.h>
#define red 12
#define blue 9
#define yellow 14
#define MAP 30
#define applex apple[0]
#define appley apple[1]
#define LEN 5
int speed = 0;
int autotexta = 1;//蛇吃后是否增长，1为增长
int autotextb = 0;//判定蛇吃自己开关，1为打开
/*刷测试模块*/
int texta = 1;//刷测试次数开关，1为开
int times = 100;//刷几次
int limit = 0;//得分最高限制，仅限于刷次数时有效,0为无限次
int pause = 0;//刷测试时结束暂停
/*自动控制模块*/
int autoall = 1;//自动控制总开关
int auto1 = 0;
int auto2 = 0;

struct snake {
	int x;
	int y;
	struct snake* next;
	struct snake* last;
};
struct snake* p1 = (struct snake*)malloc(sizeof(struct snake));
struct snake* p2 = p1;
struct snake* head = p1;
struct snake* tail;
int apple[2];

int len = LEN;
int **wall= (int**)malloc(sizeof(int*) * MAP);
void basic() {
	for (int i = 0; i < MAP; i++) {
		wall[i]= (int*)malloc(sizeof(int) * MAP);
	}
}

char ch = 'w';
int change = 1;
int scor = 0;
void gotoxy(int x, int y)//位置函数
{
	COORD pos;
	pos.X = 2 * x;
	pos.Y = y;
	SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
}
void color(int a)//颜色函数
{
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), a);
}
void wall_info() {
	for (int q = 0; q < MAP; q++) {
		for (int w = 0; w < MAP; w++) {
			wall[q][w] = 1;
		}
	}
	for (int t = 0; t < MAP; t++) {
		wall[0][t] = 0;
		wall[MAP - 1][t] = 0;
		wall[t][0] = 0;
		wall[t][MAP - 1] = 0;
	}
	for (int j = 0; j < MAP; j++) {
		for (int k = 0; k < MAP; k++) {
			if (wall[j][k]) {
				gotoxy(j, k);
				color(blue);
				printf("■");
			}
			else {
				gotoxy(j, k);
				color(blue);
				printf("□");
			}
		}
	}

}
void snake_apple() {
	for (int i = 0; i < LEN - 1; i++) {
		p1 = (struct snake*)malloc(sizeof(struct snake));
		p2->next = p1;
		p1->last = p2;
		p2 = p1;
	}
	tail = p1;
	srand((unsigned int)time(NULL));
	head->x = (MAP - 1) / 2;
	head->y = (MAP - 1) / 2;
	struct snake* lsa = head->next, * lsb = head;
	for (int i = 1; i < len; i++) {
		lsa->x = lsb->x;
		lsa->y = lsb->y + 1;
		gotoxy(lsa->x, lsb->y);
		color(yellow);
		printf("★");
		lsa = lsa->next;
		lsb = lsb->next;
	}
	gotoxy(head->x, head->y);
	color(yellow);
	printf("¤");
	int flag = 0;
	while (1) {
		struct snake* lsa = head;
		applex = rand() % (MAP - 2) + 1;
		appley = rand() % (MAP - 2) + 1;
		for (int j = 0; j < len; j++) {
			if (lsa->x == applex && lsa->y == appley) {
				flag = 1;
				break;
			}
			lsa = lsa->next;
		}
		if (!flag) break;
	}
	gotoxy(applex, appley);
	color(red);
	printf("●");
}
void movesnake() {
	if (_kbhit()) {
		fflush(stdin);
		ch = _getch();
	}
	struct snake* lsd = tail;
	if (change) {
		gotoxy(lsd->x, lsd->y);
		color(blue);
		printf("■");
	}
	//	if (scor >= 1) {
	//		gotoxy(0, 0);
	//		color(blue);
	//		printf("□");
	//	}
	struct snake* lsa = lsd;
	struct snake* lsb = lsd->last;
	for (int i = len - 1; i > 0; i--) {
		lsa->x = lsb->x;
		lsa->y = lsb->y;
		lsa = lsa->last;
		lsb = lsb->last;
	}
	switch (ch) {
	case 'w':
	case 'W': {head->y--; break; }
	case'S':
	case's': {head->y++; break; }
	case'D':
	case'd': {head->x++; break; }
	case'a':
	case'A': {head->x--; break; }
	}
	gotoxy(head->x, head->y);
	color(yellow);
	printf("¤");
	struct snake* lsc = head->next;
	gotoxy(lsc->x, lsc->y);
	color(yellow);
	printf("★");
	change = 1;
	gotoxy(MAP, MAP-1);
}
void eat_apple() {
	if (head->x == applex && head->y == appley) {
		if (autotexta) {
			len++;
			p1 = (struct snake*)malloc(sizeof(struct snake));
			p2->next = p1;
			p1->last = p2;
			p2 = p1;
			tail = p1;
		}
		scor++;
		int flag = 0;
		if (autoall) {
			int i = 0;
			while (1) {
				applex = rand() % (MAP - 2) + 1;
				appley = rand() % (MAP - 2) + 1;
				if (applex != head->x && appley != head->y)
					i = 1;
				if (i)
					break;
			}
		}
		else {
			while (1) {
				struct snake* lsa = head;
				applex = rand() % (MAP - 2) + 1;
				appley = rand() % (MAP - 2) + 1;
				for (int j = 0; j < len - 1; j++) {
					if (lsa->x == applex && lsa->y == appley) {
						flag = 1;
						break;
					}
					lsa = lsa->next;
				}
				if (!flag) break;

			}
		}
		gotoxy(applex, appley);
		color(red);
		printf("●");
		change = 1;
	}
}
int  if_wall() {
	if (head->x == 0 || head->x == MAP - 1 || head->y == 0 || head->y == MAP - 1) {
		return  1;
	}
	if (autotextb) {
		struct snake* lsa = head->next;
		for (int i = 1; i < len-1; i++) {
			if (head->x == lsa->x && head->y == lsa->y) {
				return  1;
				break;
			}
			lsa = lsa->next;
		}
	}
	return 0;
}
int l = 1, r = 1, u = 1, d = 1;
void automove3() {
	struct snake* lsa = head->next;
	if (head->x - 1 == lsa->x && head->x + 1 == MAP)
		ch = 'w';
	if (head->x + 1 == lsa->x && head->x - 1 == 0)
		ch = 's';
	if (head->y + 1 == lsa->y && head->y - 1 == 0)
		ch = 'a';
	if (head->y - 1 == lsa->y && head->y + 1 == MAP)
		ch = 'd';
}
void automove2() {
	struct snake* lsa = head->next;
	struct snake* lsb = lsa->next;
	for (int i = 1; i < len - 2; i++) {
		if (head->x - 1 == lsa->x) {
			l = 0;
			if (head->x + 1 == lsb->x && head->y == lsb->y) {
				r = 0;
			}
			else r = 1;
			if (head->y - 1 == lsb->y && head->x == lsb->x) {
				u = 0;
			}
			else u = 1;
			if (head->y + 1 == lsb->y && head->x == lsb->x) {
				d = 0;
			}
			else d = 1;
			if (r == 0 || u == 0 || d == 0)
				break;
		}
		if (head->x + 1 == lsa->x) {
			r = 0;
			if (head->x - 1 == lsb->x && head->y == lsb->y) {
				l = 0;
			}
			else l = 1;
			if (head->y - 1 == lsb->y && head->x == lsb->x) {
				u = 0;
			}
			else u = 1;
			if (head->y + 1 == lsb->y && head->x == lsb->x) {
				d = 0;
			}
			else d = 1;
			if (l == 0 || u == 0 || d == 0)
				break;
		}
		if (head->y - 1 == lsa->y) {
			u = 0;
			if (head->x + 1 == lsb->x && head->y == lsb->y) {
				r = 0;
			}
			else r = 1;
			if (head->x - 1 == lsb->x && head->y == lsb->y) {
				l = 0;
			}
			else l = 1;
			if (head->y + 1 == lsb->y && head->x == lsb->x) {
				d = 0;
			}
			else d = 1;
			if (l == 0 || r == 0 || d == 0)
				break;
		}
		if (head->y + 1 == lsa->y) {
			d = 0;
			if (head->x + 1 == lsb->x && head->y == lsb->y) {
				r = 0;
			}
			else r = 1;
			if (head->x - 1 == lsb->x && head->y == lsb->y) {
				l = 0;
			}
			else l = 1;
			if (head->y - 1 == lsb->y && head->x == lsb->x) {
				u = 0;
			}
			else u = 1;
			if (l == 0 || r == 0 || u == 0)
				break;
		}
		lsb = lsb->next;
	}
	if (l == 0 && r == 0 && d == 0)
		ch = 'w';
	if (l == 0 && r == 0 && u == 0)
		ch = 's';
	if (r == 0 && u == 0 && d == 0)
		ch = 'a';
	if (l == 0 && u == 0 && d == 0)
		ch = 'd';
	//还有lrud其中有两个为0的情况，其中有八种情况

}
void automove1() {
	struct snake* lsa = head->next;
	if (head->x - 1 != lsa->x|| head->x + 1 != lsa->x) {
			if (head->y > appley&&u==1)
				ch = 'w';
			else if (head->y < appley&&d==1)
				ch = 's';
			
	}
	if (head->y - 1 != lsa->y || head->y + 1 != lsa->y) {
		if (head->x > applex&&l==1)
			ch = 'a';
		else if (head->x < applex&&r==1)
			ch = 'd';
	}
}
void automove() {
	automove1();
	if(auto1)
		automove2();
	if (auto2)
		automove3();
}
int main() {
	basic();
	if (!texta) {
		wall_info();
		snake_apple();
		while (1) {
			movesnake();
			Sleep(speed);
			eat_apple();
			if (autoall) {
				automove();
			}
			if (if_wall()) {
				break;
			}
			gotoxy(MAP+2, 10);
			color(yellow);
			printf("得分%4d分", scor);
			gotoxy(0, 0);

		}
		gotoxy(MAP / 2, MAP / 2);
		color(red);
		printf("游戏结束，得分%d", scor);
	}
	if (texta) {
		int line = 0,lie=0;
		struct scors
		{
			int x;
			struct scors* next;
		};
		struct scors* p3, * p4, * hind;
		hind = p3 = p4 = (struct scors*)malloc(sizeof(struct scors));
		int i = 0;
		while (i < times) {
			if (i % 25 == 0) {
				line++;
				lie = 0;
			}
			lie++;
			wall_info();
			snake_apple();
			gotoxy(MAP+2, 1);
			color(yellow);
			printf("第 %d 次测验,总共有 %d 次", i + 1, times);
			if (i != 0) {
				gotoxy(MAP+2, lie + 2);
				color(yellow);
				printf("第%d次测试成绩%d", i ,scor );
			}
			scor = 0;
			while (1) {
				movesnake();
				Sleep(speed);
				eat_apple();
				if (autoall) {
					automove();
				}
				if (if_wall()) {
					break;
				}
				gotoxy(MAP+2, 2);
				color(yellow);
				printf("得分%.4d分", scor);
				gotoxy(0, 0);
				if (limit != 0) {
					if (scor > limit)
						break;
				}
			}
			gotoxy(applex, appley);
			color(red);
			printf("●");
			if(pause)
			system("pause");
			p3->x = scor;
			p3= (struct scors*)malloc(sizeof(struct scors));
			p4->next = p3;
			p4 = p3;

			struct snake* end = tail->last;
			for (int i = 2; i < len; i++) {
				free(end->next);
				end = end->last;
			}
			p1 = p2 = head;
			len = LEN;
			i++;
		}
		p4->next = NULL;
		int all = 0;
		while (hind->next != NULL) {
			all += hind->x;
			hind = hind->next;
		}
		gotoxy(MAP+2, lie + 2);
		color(yellow);
		printf("平均成绩 %d", all / times);
	}
	system("pause");
}
Harari赵
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
智能蛇——自己找食物吃的贪吃蛇
White3zz的博客
12-27 3302
上一篇博客中我们简单实现了如何用C语言编写一个简易的贪吃蛇，具体实现代码可以见用C语言设计贪吃蛇 ，并提到了可以使贪吃蛇具有“智能”，使其能够自动寻找食物。下面我们来看看如何实现这一功能 设计思路如下： 定义一个函数，用于判断蛇的下一步该往哪个方向走 函数伪代码如下： function whereGoNext(Hx,Hy,Fx,Fy)  // Hx,Hy: 头的位置，
Java写一条吃全屏幕的贪吃蛇（A*自动寻路算法和一些简单的策略） 三
Sober_yang的博客
03-26 3300
这几天在琢磨反射和动态代理，难度有点高，这博客拖了好久才来完成它。虽然在学校学习了Java和一些其他语言，但是高级特性接触得都不多，主要还是面向过程编程，看了这么多书，慢慢的体悟了面向对象的好处，内心十分触动。以后写代码尽量做到功能单一，便于拓展，便于维护，面向对象。    贪吃蛇吃满屏幕的要点在于，要有一条安全的路径，不管发生什么情况，只要安全路径存在，贪食蛇就能坚持走下去，所以第一步我们要找一...
C++贪吃蛇自动吃食物
07-20
可以自动吃食物，但是本算法考虑因素较低，读懂本程序，可以在上面进行扩展。
贪吃蛇AI.rar基于java实现的，自动吃食物
03-17
贪吃蛇自动吃食物，基于Java+swing实现的
C语言链表实现贪吃蛇游戏
08-29
贪吃蛇游戏是一款广为人知的休闲游戏，玩家控制一条蛇在屏幕上移动，通过吃食物来增长长度，同时避免碰撞到自己的身体或游戏边界。 首先，我们需要了解链表在实现游戏中的作用。在贪吃蛇游戏中，链表被用来存储蛇的...
C语言实现链表贪吃蛇
12-17
本文实例为大家分享了C语言实现贪吃蛇的具体代码，供大家参考，具体内容如下 用C语言链表写的贪吃蛇（程序设计时做的，做的不好大佬勿喷） 借助游戏内容分析贪吃蛇所需的功能主要包括这几块： 1.移动光标模块 2....
C++控制台循环链表实现贪吃蛇
12-20
在本文中，我们将探讨如何使用C++通过循环链表在控制台实现经典的贪吃蛇游戏。循环链表是一种数据结构，特别适合表示蛇的身体部分，因为它可以方便地添加和删除节点，模拟蛇移动和吃食物的过程。以下是实现这个游戏...
java中使用双向链表实现贪吃蛇程序源码分享
09-03
双向链表的特性使得在链表的任何位置添加或删除节点都具有O(1)的时间复杂度，这在处理动态变化的蛇身长度时非常有用。 总的来说，Java中的双向链表是一种强大且灵活的数据结构，可以有效地解决贪吃蛇游戏中蛇的移动...
贪吃蛇Python实现（手动+自动模式）
qq_41562704的博客
03-20 4945
1.背景介绍 2013大火的贪吃蛇图片，网上也有不少的算法实现，在大佬的基础上，将手动与AI模式结合在一起，重构了一下，同时利用另一种Astar寻路算法优化AI模式。 参考文章：https://www.w3cschool.cn/python3/python3-73gj2zjd.html 2.启动页和结束页绘制 首先先设置一下游戏的基本设置，创建settings.py文件，在该文件中创建...
Java贪吃蛇的简单实现
wang11234ilike的博客
11-23 1707
贪吃蛇游戏主要表现为蛇吃食物，吃到食物即身体边长，碰到墙壁或吃到自己即死亡 主要的难点如下： 1：控制蛇转向，不能与当前方向相反，即不能首尾互换 2：蛇头转向后蛇身也应当跟随蛇头的路径 3：蛇吃食物后身体的增长 4：蛇死亡条件的判断
自动寻路贪吃蛇百分百吃满屏幕
cx_cs的博客
03-08 709
贪吃蛇
智能蛇
ben_tsai的博客
12-24 288
实现贪吃蛇自动吃食物，显然用的是A*寻路算法。 以下为细节 首先，分析蛇的状态无非以下三种： 1、能吃食物，吃完食物后还能找到尾巴，这时候就直接去吃食物。 首先，分析蛇的状态无非以下三种： 2、蛇不能吃食物，或者吃食物后找不到尾巴（找不到尾巴还去吃是不允许的，这回导致吃完后无路可走），这时候就跟着蛇尾巴走，走到能去吃食物为止。 3、在状态2的前提下，尾巴都找不到，只能随便走一步
前几天搞定了贪吃蛇自动寻路算法……
热门推荐
blankmanp的专栏
05-24 1万+
写了几天，搞定了贪吃蛇自动寻路……目前在20*20的格子上面可以稳定跑到100+分，200+的话……看运气吧o(╯□╰)o，总之算法还有很多可以修改的地方，而且UI部分还有部分没写的…… 总结下：这次写的话主要算法用的是BFS，没有用A*算法，因为太复杂了，用JS实现感觉好难，所以暂时没有写……然后有两种策略，一种是吃到食物还能找到自己尾巴的话就直接去吃食物，如果发现找不到吃食物的路径OR吃了就会
Java写一条吃满屏幕的贪吃蛇（A*自动寻路算法和一些简单的策略） 一
Sober_yang的博客
02-27 3905
    一个月没有写博客，中间其实学了不少东西，因为是自学，所以进度很慢，同时在看Java核心技术还有李刚的疯狂Java，这两本书讲的很详细，另外也学着看一点源代码。特别是IO流的部分，类太多让人比较晕，一连学了快一个星期，看了一点源代码，最后才缕清了思路。    之前学到list,发现这个ArrayList真是一个好东西，不用像数组一样预先要声明空间大小,可以动态的增长和缩减，可以保存任意类型的...
贪吃蛇部分代码，吃了食物不能就不行了，是怎么回事？
陈刚编程心得与知识集
04-17 1175
#include #include #include #include #define S 100 #define HEIGHT 20 #define WIDTH 80 int m,n; void gotoxy(int x ,int y) { COORD pos={x,y}; HANDLE hOut=GetStdHandle(STD_OUTPUT_HANDLE);
Python菜鸟快乐游戏编程_pygame
09-17
此课程目的是激发大家对编程兴趣，给广大Python入门初学者带来无穷乐趣。游戏涉及童年玩过经典小游戏，包括贪吃蛇，消消乐，俄罗斯方块，植物大战僵尸，扫雷等等。视频的参考资料可下载脚本。脚本已经编译好，可直接运行！
贪吃蛇游戏实现（链表）
qq_39950673的博客
01-04 754
#C语言实现贪吃蛇 ##一、需求 ###通过游戏的实现，学习C语言知识的综合应用，以及解决问题的方法。 ###1、通过wasd操作控制蛇的运动方向； ###2、蛇运动时不能碰到墙壁和自己的身体； ###3、食物动态产生，存在时间不同，分值不同； ###4、游戏可以暂停； ###5、游戏可以保存进度，有不同的版本； ###6、启动游戏可以从保存的进度开始游戏，也可以重新开始游戏； ##二、原理 ##...
c语言贪吃蛇蛇身加长链表
最新发布
03-18
C语言贪吃蛇游戏中，蛇身的加长可以通过链表来实现。链表是一种数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在贪吃蛇游戏中，每当蛇吃到食物时，就需要在蛇尾添加一个新的节点来表示蛇身...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值