用c语言实现简易贪吃蛇

最新推荐文章于 2024-08-06 20:47:18 发布
最新推荐文章于 2024-08-06 20:47:18 发布
阅读量2.4k 收藏 22
点赞数 5
分类专栏： Ｃ 数据结构 文章标签： c语言 贪吃蛇
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MQ9982/article/details/82941196
版权

       我们先分析游戏的功能需求：有一块区域，区域内有一条蛇和一个食物，蛇通过上下左右移动到达食物所在的点，蛇吃到食物，蛇长度增加，重新生成食物，分数增加，如果蛇头碰到自己的身体或者区域边界，游戏结束。否则，游戏继续。

我们用MVC的框架来实现它，即 Model——View——Controller：

       Model：定义和实现相关的结构体类型以及功能函数
       View：定义和实现所有输出相关的函数
       Controller：定义和实现游戏逻辑相关的函数，将Model和View中的函数联系起来

从Model中先开始看

       首先，我们需要知道在贪吃蛇的游戏中，我们会用到哪些结构体，通过这些结构体，我们基本可以构造出一个贪吃蛇的游戏。这里先附上我贪吃蛇的游戏界面，方便构思：
在这里插入图片描述
       通过这幅图，我们先来分析一波：在界面中出现的元素都有 蛇 食物 墙 分数 操作提示 分数排行榜。
       现在，我们就需要将他们一一表示出来：
       蛇：
              1.    蛇的属性可以简单的分解为：蛇头，蛇尾，蛇前进的方向，蛇前进的速度。
              2.    由于蛇是动态增长的，所以用链表的形式来保存，链表的每个节点都由一个数据域和一
              个指针域组成。因此需要一个节点类型的变量。然后将这些变量连接起来形成链表。当贪吃
              蛇吃食物变长时，为了减少时间复杂度，我们用链表的头当蛇的尾巴，链表的尾当蛇的头。
              当蛇前进时，增加蛇头就等于链表的尾插，删除蛇尾就等于链表的头删，因此它的时间复杂
              度都是为O(1)。

在这里插入图片描述

              3.    在这里数据域是为了表示坐标，因此我们需要一个新的类型来表示坐标，这个类型包含
              两个元素，即 X 和 Y。
              4.    蛇前进的方向只有四种，即：上 下 左 右 因此，我们用枚举的方式来定义。
       结合上面的四点，我们需要定义的结构体就有：

typedef enum Direction{               //方向
	UP, DOWN, LEFT, RIGHT
}Direction;

typedef struct Position{				//节点的数据域
	int x;
	int y;
}Position;

typedef struct Node{                     //节点
	Position pos;
	struct Node *next;
}Node;


typedef struct Snake{                 //蛇的结构体
	Node *head;
	Node *tail;
    int speed;					//我们通过Sleep函数来控制蛇的前进速度
	Direction direction;
}Snake;

       食物 分数 分数排行榜：
              1.     食物的属性只有一种，即 食物的坐标 ，而坐标实质即为之前定义的Position类型的一
               个变量。
              2.     分数，只需要用一个整型的变量记录当前分数，并在每一次移动后刷新输出即可。
              3.     分数排行榜，每次游戏结束后，将本次的分数与已存储的分数比较，将前十再次存储
               即可。
       墙 操作提示 ：
              1.    这两种元素，只需要给定一个坐标，将需要输出的内容输出即可
       我们对上面的所有元素进行一次封装，将它们封装在一个结构体内：

typedef struct Game {
	Snake snake;        //蛇
	Position food;      //食物坐标
	int width;          //宽
	int height;         //高
    int score;          //分数
}Game;

       到这里，贪吃蛇中用到的结构体基本就构建完成了，下面我们来分析执行的操作：
             1.     首先，我们需要对游戏进行初始化：即 ：初始化蛇的各项属性 初始化食物的位置 初始化
              分数 初始化游戏界面
                     上面这些功能我们可以封装到一个函数内，即初始化游戏 ，在初始化蛇的属性时，我们
              需要给定蛇头的位置和蛇前进的方向 蛇的长度 这样我们就能将几个连续的坐标连接成一条蛇
              最后还需要给定蛇的速度。


#define DEFAULT_HEAD 8
void SnakeInitialize(Snake *pSnake)     
{
    int i = 0;
    assert(pSnake != NULL);
    pSnake->direction = LEFT;
	pSnake->speed = 300;
    pSnake->head = NULL;
	pSnake->tail = NULL;
			//链表		    	尾						头
     // 这里给出的蛇坐标为 ： （8，8） <- （9， 8） <-（10， 8）
     		//pSnake           head 				   tail
     		//这里默认蛇的长度为3
    for(i = DEFAULT_HEAD; i < DEFAULT_HEAD + 3; i++) {
        int x = DEFAULT_HEAD + i;
        int y = DEFAULT_HEAD;
        Node *newnode = (Node *)malloc(sizeof(Node));
        assert(newnode != NULL);
        newnode->pos.x = x;
        newnode->pos.y = y;
        newnode->next = pSnake->tail;
        pSnake->tail = newnode;
		if (pSnake->head == NULL) {
			pSnake->head = pSnake->tail;
		}
    }
}

                     初始化食物的位置时，我们用随机生成的方式，在游戏的范围内生成即可，同时，食物
              也不能出现在蛇的身体上。

void GenerateFood(Game *pgame)
{
    int x = 0, y = 0;
    assert(pgame != NULL);
    do {
        x = rand()%(pgame->width);
        y = rand()%(pgame->height);
    }while(IsInSnake(x, y, &(pgame->snake)));
    //IsInSnake(x, y, &(pgame->snake) 用来判断是否在蛇的身体上。
    //如果在 返回 1  循环继续 如果不在 返回 0 跳出循环
    (pgame->food).x = x;
    (pgame->food).y = y;
}

                     最后我们将它们封装在 初始化游戏中：

void GameInitialize(Game *pgame)
{
    assert(pgame != NULL);
    pgame->height = 28;
    pgame->width = 28;
    SnakeInitialize(&(pgame->snake));
    GenerateFood(pgame);
    pgame->score = 0;
}

              2.     而当游戏进行时，我们需要执行的操作有：蛇前进 判断蛇是否吃到食物 判断游戏是否结
              束判断分数是否增加 。Model中我们只实现操作相关的函数，判断相关的函数在Controller中
              实现。
                      关于蛇前进的操作其实只有两步，即：① 将下一个到达的坐标置为蛇头 ② 将当前的蛇
              尾去掉。而因为我们的蛇头是链表的尾，所以只需要让当前的头的next 指向新的节点即
              可。删除蛇尾也就是进行一次链表的头删。

//蛇增加头     链表的尾插
void SnakeAddHead(Snake *pSnake, Position *nextpos)
{
    assert(pSnake != NULL);
    Node *newnode = (Node *)malloc (sizeof(Node));
    assert(newnode != NULL);
    newnode->pos.x = nextpos->x;
    newnode->pos.y = nextpos->y;
    newnode->next = NULL;
	PrintSnakeBlock(&(pSnake->head->pos), nextpos);
	//	PrintSnakeBlock在View 中实现
    pSnake->head->next = newnode;
    pSnake->head = newnode;
}

//蛇删除尾   链表的头删
void SnakeRemoveTail(Snake *pSnake)
{
    Node *del = NULL;
    assert(pSnake != NULL);
    del = pSnake->tail;
	pSnake->tail = pSnake->tail->next;
	CleanSnakeBlock(&(del->pos));
	//CleanSnakeBlock在View 中实现
	free(del);
    del = NULL;
}

              3.     最后游戏结束时，我们需要执行的操作有：刷新排行榜 销毁游戏
                      游戏开始时，我们先将排行吧中的数据取出来，游戏结束时，判断新的成绩能否加入排
               行榜，（判断的方式是对排行榜个数 + 1 个数进行排序，等到保存和输出的时候，只保存
               排行榜个数个数据。比如：排行榜保存前10名 ，当取出10个成绩后，将它们保存在一个大
               小为11的数组中，将本局分数存入最后一个，进行排序，前10个就为新的排行榜）并将排
               行榜数据再次保存。最后再将蛇的身体链表free掉即可。

//读取排行榜
void SnakeRankRead(int size, int *prank)
{
	int i = 0, k = 0;
	assert(prank != NULL);
	FILE *pf = NULL;
	pf = fopen("Rank.dat", "a");
	pf = fopen("Rank.dat", "r");
	assert(pf != NULL);
	while ((i < size) && ((k = fgetc(pf)) != EOF)) {
		(*(prank + i++)) = k;
	}
}
//保存排行榜
void SnakeRankSave(int size, int *prank)
{
	int i = 0;
	FILE *pf = NULL;
	assert(prank != NULL);
	pf = fopen("Rank.dat", "w");
	assert(pf != NULL);
	for (i = 0; i < size; i++) {
		fputc(*(prank + i), pf);
	}
}
//销毁蛇身体
void SnakeDestroy(Snake *pSnake)
{
	Node *del, *cur = NULL;
	assert(pSnake != NULL);
	for (cur = pSnake->tail; cur != NULL;) {
		del = cur;
		cur = cur->next;
		free(del);
	}
	pSnake->head = NULL;
	pSnake->tail = NULL;
	pSnake->speed = 0;

}
再看View

       我们说过View 中实现的是与输出相关的，游戏中的输出则共有下面几种：输出蛇 输出食物 输出边界 输出提示 输出分数 输出排行榜 开始界面
       View中的输出我们而已采用移动光标的方式来做，这里用SetConsoleCursorPosition函数来实现。

//X 为横 Y 为纵
static void SetCurPos(int X, int Y)
{
	HANDLE hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
	COORD coord = { X, Y };
	SetConsoleCursorPosition(hStdOutput, coord);
}

       因为我们在前面定义的边界为28*28，我们是从左上角，也就是（0，0）的位置开始输出，又因为中文字符占两个坐标位置，因此，在输出时需要对输出的界面进行转换。

static void NewCurPos(int X, int Y)
{
	X = 2 * (X + 1);
	Y = Y + 1;
	SetCurPos(X, Y);
}

       为了界面的美化，我们还需要一个隐藏光标的函数：

void ViewInit(int width, int height)
{
	HANDLE hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_CURSOR_INFO info;
	GetConsoleCursorInfo(hStdOutput, &info);
	info.bVisible = 0;
	SetConsoleCursorInfo(hStdOutput, &info);
}

输出蛇 ：     输出蛇分为两种：一种是最开始的时候我们需要将整个蛇输出。另外一种是蛇在前进过
              程中的输出。在这里我们采用局部刷新的方法，即：当蛇前进一步时，我们在新的蛇头的位
              置输出一块蛇的身体，在原来蛇尾的部分输出两个空格（蛇的身体为中文字符，占两个空格
              ）。这样我们就可以根据光标的移动输出，来显示蛇的前进。

//输出蛇
void PrintSnake(const Snake *pSnake)
{
	Node *cur = NULL;
	assert(pSnake != NULL);
	for (cur = pSnake->tail; cur != NULL; cur = cur->next)
	{
		NewCurPos((cur->pos).x, (cur->pos).y);
		if (cur == pSnake->head) {
			printf("⊙");
		}
		else {
			printf("※");
		}
	}
	SetCurPos(65, 16);

}
//新输出的蛇头
void PrintSnakeBlock(const Position *prevpos, const Position *curpos)
{
	NewCurPos(prevpos->x, prevpos->y);
	printf("※");
	NewCurPos(curpos->x, curpos->y);
	printf("⊙");
}
//清除掉的蛇尾
void CleanSnakeBlock(const Position *curpos)
{
	NewCurPos(curpos->x, curpos->y);
	printf("  ");
}

输出食物 输出边界 输出提示 输出分数 输出排行榜 开始界面：
                   只需要将光标移动到指定位置输出即可：

//输出界面
void PrintStart0(int width, int height)
{
	ViewInit(width, height);
	NewCurPos(width / 4, height / 2);
	printf("PRESS SPACE TO START GAME ！");
}
void PrintStart1(int width, int height)
{
	NewCurPos(width / 4, height / 2);
	printf("                            ");
}

void PrintEnd(int width, int height)
{
	NewCurPos(width / 3, height / 2);
	printf("GAME OVER！");
	NewCurPos(width + 2, height);
}

void PrintWall(int width, int height)
{
	int i = 0;


	//上
	SetCurPos(0, 0);
	for (i = 0; i < width + 2; i++) {
		printf("█");
	}


	//左
	for (i = 0; i < height + 2; i++) {
		SetCurPos(0, i);
		printf("█");
	}

	//下
	SetCurPos(0, height + 1);
	for (i = 0; i < width + 2; i++) {
		printf("█");
	}

	//右
	for (i = 0; i < height + 2; i++) {
		SetCurPos(2 * (width + 1), i);
		printf("█");
	}
}
//输出食物
void PrintFood(const Position *pFood)
{
	NewCurPos(pFood->x, pFood->y);
	printf("●");
}
//输出分数
void PrintScore(int width, int height, int score)
{
	NewCurPos(width + 2, height / 3);
	printf("当前分数：%d", score);
}
//输出排行榜
void PrintRank(int width, int height, int size, const int *pscore)
{
	int i = 0;
	assert(pscore != NULL);
	NewCurPos(width + 15, 0);
	printf("Rank:");
	for (i = 1; i <= size; i++) {
		NewCurPos(width + 15, i);
		printf("第%2d名：%5d分", i, *(pscore + i - 1));
	}
}
//输出提示
void PrintFunction(int width, int height)
{
	NewCurPos(width + 2, height / 2);
	printf("空格键暂停");
	NewCurPos(width + 2, (height / 2) + 5);
	printf("长按方向键加速");
}

       因为上面这些函数在游戏的一开始就需要整体进行一次输出，因此我们将它们封装在一个函数内部，方便调用，在需要单独输出时，再单独调用即可。

void PrintGame(const Game *pGame)
{
	PrintWall(pGame->width, pGame->height);
	PrintSnake(&(pGame->snake));
	PrintScore(pGame->width, pGame->height, pGame->score);
	PrintFunction(pGame->width, pGame->height);
}
最后是Controller的部分

       在这里我们将Model中的函数以及View中的函数联系起来，最后组成我们的贪吃蛇。

  1. 游戏开始：
    a. 进行界面输出 PrintGame
    b. 游戏的初始化 GameInitialize
    c. 从排行榜文件中读取数据
               将以前的排行榜中的数据取出来，存放在一个比排行榜容量大1的数组中。
#define DEFAULT_RANKNUM 10
int *prank = NULL;
prank = (int *)malloc(sizeof(int) * (DEFAULT_RANKNUM + 1));
SnakeRankRead(DEFAULT_RANKNUM, prank);
  1. 游戏进行：
    a. 输出食物 PrintFood
    b. 输出当前分数 PrintScore
    c. 进行按键操作
           这里我们用到了GetAsyncKeyState函数来检测我们按下的键，当我们按下一个键，并且目前蛇的方向与我们按下键的方向不是反方向时，蛇的方向更改为我们按下的键的方向。如果本次按下的键的方向与上次的相同，那么蛇的前进速度增加。也就是speed的值减小，在这里我使用了一个固定值50，这并不会改变蛇自身的速度的值，只是通过isspeed这个标记的值来决定，使用当前的速度，还是固定值50，作为本次循环中Sleep 函数的值。如果我们按下了空格，那么游戏会进入暂停状态，直下一次按下空格。
		if (GetAsyncKeyState(VK_UP) && game.snake.direction != DOWN) {
			if (game.snake.direction == UP) {
				isspeed = 1;
			}
			game.snake.direction = UP;
		}
		else if (GetAsyncKeyState(VK_DOWN) && game.snake.direction != UP) {
			if (game.snake.direction == DOWN) {
				isspeed = 1;
			}
			game.snake.direction = DOWN;
		}
		else if (GetAsyncKeyState(VK_LEFT) && game.snake.direction != RIGHT) {
			if (game.snake.direction == LEFT) {
				isspeed = 1;
			}
			game.snake.direction = LEFT;
		}
		else if (GetAsyncKeyState(VK_RIGHT) && game.snake.direction != LEFT) {
			if (game.snake.direction == RIGHT) {
				isspeed = 1;
			}
			game.snake.direction = RIGHT;
		}
		else if (GetAsyncKeyState(VK_SPACE)) {
			Pause();
		}

    d. 判断食物是否被吃。
           只需要判断蛇头的位置是否在食物的坐标处即可。当走到这一步的时候，已经检测过一次按键
    了，所以蛇头已经变为了新的方向上的蛇头，因此在这一步需要获取下一个坐标，GetNextPos 也
    就是新的蛇头的位置。用新的蛇头的位置和食物的位置做比较。
           i. 如果被吃：增加蛇头，更新分数，生成新的食物。
           ii. 如果没有被吃：增加蛇头，删除蛇尾。

		//获取新的蛇头的坐标
		static Position GetNextPos(const Snake *pSnake)					
		{
				assert(pSnake != NULL);
				Position nextpos = pSnake->head->pos;
				switch(pSnake->direction) {
				case UP:
					nextpos.x = (pSnake->head->pos).x;
					nextpos.y = (pSnake->head->pos).y - 1;
					break;
				case DOWN:
					nextpos.x = (pSnake->head->pos).x;
					nextpos.y = (pSnake->head->pos).y + 1;
					break;
				case LEFT:
					nextpos.x = (pSnake->head->pos).x - 1;
					nextpos.y = (pSnake->head->pos).y;
					break;
				case RIGHT:
					nextpos.x = (pSnake->head->pos).x + 1;
					nextpos.y = (pSnake->head->pos).y;
					break;
			}	
			return nextpos;
		}
		//判断食物是否被吃
		static int IsEat(const Position *pFood, const Position *nextpos)
		{
				return (pFood->x == nextpos->x) && (pFood->y == nextpos->y);
		}
		//判断按完之后的情况
		Position nextpos = GetNextPos(&(game.snake));
		//走的这里的时候，蛇的头部已经到达了下一个坐标处，只差赋值
		// 吃到食物   没吃食物
		if (IsEat(&(game.food), &nextpos)) {
			//吃到食物 尾巴不变 头变长一个  重新生成食物  分数增加
			GenerateFood(&game);
			if (game.snake.speed > 80) {
				game.snake.speed -= 5;
			}
			game.score += 10;
		}

    e. 判断游戏是否结束。
                判断游戏是否结束，只需要判断蛇头与边界是否重合、蛇头与自身除蛇头以外的位置是否重合即可。

static int GameOver(const Game *pGame)
{
	Node *cur = NULL;
	assert(pGame != NULL);


	//左边
	if (pGame->snake.head->pos.x < 0) {
		return 1;
	}
	//右边
	if (pGame->snake.head->pos.x >= pGame->width) {
		return 1;
	}
	//上边
	if (pGame->snake.head->pos.y < 0) {
		return 1;
	}
	//下边
	if (pGame->snake.head->pos.y >= pGame->height) {
		return 1;
	}
	//自己
	for (cur = pGame->snake.tail; cur != pGame->snake.head; cur = cur->next) {
		if (cur->pos.x == pGame->snake.head->pos.x && cur->pos.y == pGame->snake.head->pos.y) {
			return 1;
		}
	}

	return 0;
}

           i. 如果结束，跳出循环。
           ii. 如果没有结束，继续重复游戏进行的动作。
3. 游戏结束：
    a. 输出结束界面PrintEnd
    b. 更新排行榜
           将本局的分数存入存放排行榜分数数组的最后一位，从最后一位往前排序，将排行榜个数的数
    据从前到后输出，并保存。

	(*(prank + DEFAULT_RANKNUM)) = game.score;
	SnakeScoreSort(DEFAULT_RANKNUM + 1, prank);
	SnakeRankSave(DEFAULT_RANKNUM, prank);
	PrintRank(game.width, game.height, DEFAULT_RANKNUM, prank);

    c. 游戏销毁 GameDestroy

上面只是讲了实现的思路和框架，代码并不是很全，所以在最后附上代码地址：

Mmmmmmmi

以上即为本篇所有内容，不足之处还望指正。

白玉豆腐汤
关注
专栏目录
贪吃蛇C语言实现(简易版)
qq_37074040的博客
01-28 9万+
一 引言 刚学习完C语言，寒假就迫不及待的学习这个贪吃蛇小程序。不得不说，写完还是大有收获的。 二 基本原理 对于贪吃蛇怎么在屏幕上移动，当初自己也是懵逼，哈哈。其实就是不断刷新屏幕，在一个循环里，每一次循环就像一张图片，以计算机的强大计算速度，连接成动态移动的蛇轻而易举。 代码由5个主要函数组成： 1.首先初始化地图，包括围墙，蛇和食物。 2.是否产生食物，判别条件为蛇头
C语言实现简易贪吃蛇
wander303的博客
12-01 4204
前言： 本人C语言并不好（大一新生），只是刚好学到链表时发现它很符合贪吃蛇的设定，所以突发奇想写了这个贪吃蛇。代码有点呆，因为我只是想实现可以动的贪吃蛇，并没有考虑到优化运行速度，本来画蛇还需要更新头尾的，我一开始也是如此，但发现容易出问题，就干脆更新整个蛇身体了，发这篇文章仅仅是因为第一次写了一个算是有点可玩性的游戏很高兴想分享给大家而已。（虽然说这是个被玩烂了的、写烂了的游戏。再次声明：代码很拙劣，大佬勿喷。不过应该属于容易看懂的类型吧。。。。 基本原理： 因为蛇的身体所带数据结构都是相同的，又有
基于C语言实现的贪吃蛇
06-09
本源代码为基于C语言实现的贪吃蛇，通过链表实现，具有打分、存储分数等功能，可以供新学习的同学进行参考与借鉴
C语言实现贪吃蛇
04-07
一 个 用 C 语 言 写 的 贪 吃 蛇 小 游 戏，仅供参考
c语言实现贪吃蛇小游戏（巨细详解，附完整代码）
最新发布
TTKunn的博客
08-06 1366
使用c语言实现贪吃蛇小游戏（以链表为主要结构），内容讲解巨细，含完整代码，包看包会。
C语言贪吃蛇
11-01
该贪吃蛇主要描述C语言如何用数组实现简单的贪吃蛇的功能，该贪吃蛇并未实现自动行走和死亡事件。
C语言——贪吃蛇
qq_42659926的博客
06-05 288
c语言实现贪吃蛇。 利用链表存储贪吃蛇坐标，利用光标跳转打印覆盖贪吃蛇。 #include"stdio.h" #include"stdlib.h" #include"conio.h" #include"windows.h" #include"time.h" void enter();//进入界面 void over();//结束界面 void bawn();//围墙打印 void gotoprin...
C语言实现简易版贪吃蛇
06-18
在本项目中，我们将探讨如何使用C语言实现一个简易版的贪吃蛇游戏。C语言是一种基础且强大的编程语言，适合开发这样的小游戏。这个项目旨在帮助初学者理解C语言的基本结构，以及如何通过控制台输出实现游戏逻辑。 ...
用C语言实现简易贪吃蛇
H_Strong的博客
08-25 673
简易贪吃蛇（c语言） 贪吃蛇游戏是指在规定的方框内，通过操控键盘上的 ↑ ↓ ← → 键 来进行贪吃蛇的方向控制。在方框内吃掉随机出现的食物来延长蛇的身体。 需要的头文件及函数原型 #ifndef __SNAKE_H__ #define __SNAKE_H__ #define _CRT_SECURE_NO_WARNINGS 1 #include &amp;lt;stdio.h&amp;gt; #in...
C语言控制台实现简易贪吃蛇
10-22
C语言利用console实现贪吃蛇游戏，涉及到的知识点有基本语法if、for等，以及数组、枚举类型、指针、结构，能够较为充分地总结C语言基础部分地学习，可供同学们参考。同时在这里画个大饼，以后可能会对该程序地代码...
基于easyx和C语言的简易贪吃蛇游戏源码
08-16
本项目“基于easyx和C语言的简易贪吃蛇游戏源码”就是将这两者结合，为初学者提供了一个很好的实践平台，帮助他们理解C语言的基本结构和easyX库的使用。 首先，我们来看一下`snake.cpp`这个文件。这是游戏的核心...
贪吃蛇（C语言）
10-16
贪吃蛇游戏C语言源码，无图形界面，简易游戏
c语言贪吃蛇
02-04
编译器devc++ 写的不是很好，源码供新手学习 有什么意见请评论
贪吃蛇—C语言
lanse_l的博客
07-11 1586
Windows系统下C语言控制台小游戏—贪吃蛇
【C语言】贪吃蛇
chlemon的博客
10-06 2617
 一，涉及知识点： 结构体链表，动态分配内存，键盘输入检测，设置光标。  二，实现逻辑 1，涉及多个结构体，分别定义蛇，方向，结点，位置坐标，游戏 2，结点串联形成链表，遍历获取成员坐标，打印符号得到蛇身。 3，不断的加头，去尾，重新遍历坐标，再打印形成蛇的移动。 4，食物产生的位置判定，不能越界，也不能与蛇身体重合。 5，蛇的转向判定，一条规则，不允许倒退。 6，转向的实现，跟...
简易贪食蛇-C语言实现
performance
09-06 680
有空再添加注释，并且重构优化；时间足够的情况下会使用其他语言，并增加GUI。 #include #include #include #include #include #include #define N 21 int apple[3]; char score[3]; char tail[3]; void gotoxy(int x, int y) //输出坐标 {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值