贪吃蛇小游戏

ア灬格子衬衫々

已于 2024-04-09 12:16:38 修改

阅读量669

点赞数

分类专栏： # C /C++ 文章标签：游戏 c语言 c++

于 2020-07-22 21:18:18 首次发布

本文链接：https://blog.csdn.net/qq_43573663/article/details/107523315

版权

C /C++ 专栏收录该内容

13 篇文章 13 订阅

订阅专栏

文章目录

案例一

#include <stdio.h>

#include <windows.h>

#include <conio.h>

#include <time.h>

//游戏窗口

#define FrameX 4//游戏窗口左上角的X轴坐标

#define FrameY 4//游戏窗口左上角的Y轴坐标

#define Frame_height 20//游戏窗口的高度

#define Frame_width 20//游戏窗口的宽度

//定义全局变量

char reg_name[30]="",reg_pwd[10]="";

char on_name[30],on_pwd[10];

int i,j;

int a[2];//用于记住蛇尾坐标，其中a[0]、a[1]分别表示横、竖坐标

//声明蛇的结构体

struct Snake {

	int x[100];//蛇的横坐标，其中x[0]表示蛇尾的横坐标，x[N-1]表示蛇头的横坐标

	int y[100];//蛇的竖坐标，其中y[0]表示蛇尾的竖坐标，y[N-1]表示蛇头的竖坐标

	int count;//蛇吃食物的个数

	int length;//蛇的长度

	int speed;//蛇的速度

};

//声明食物的结构体

struct Food {

	int x;//食物的横坐标

	int y;//食物的竖坐标

};



/******光标移到指定位置**************************************************************/

void gotoxy(HANDLE hOut, int x, int y) {

	COORD pos;

	pos.X = x;//横坐标

	pos.Y = y;//纵坐标

	SetConsoleCursorPosition(hOut, pos);//设置控制台(cmd)光标位置 

}

/******设置文本为绿色*****************************************************************/

void Set_TextColor_Green (void) {

	HANDLE Handle = GetStdHandle(STD_OUTPUT_HANDLE);//HANDLE：句柄，是Windows用来表示对象的（不是C++的对象），HWND是其中一种，HWND是HANDLE，但HANDLE不只是HWND，HANDLE是一个通用句柄表示，HWND是一个专用表示窗口的句柄。更具体的可查找MSDN。包含在winnt.h头文件中。
												
													//GetStdHandle是一个Windows API函数。它用于从一个特定的标准设备（标准输入、标准输出或标准错误）中取得一个句柄（用来标识不同设备的数值）。
	
	SetConsoleTextAttribute(Handle, FOREGROUND_INTENSITY | FOREGROUND_GREEN);//SetConsoleTextAttribute是一个可以在API（应用程序编程接口）中设置控制台窗口字体颜色和背景色的计算机函数，该函数被广泛应用于电脑编程与软件开发中。

}

/******制作游戏窗口******************************************************************/

void make_frame() {

	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量

	gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+13);//打印选择菜单

	printf("Esc 退出游戏");

	gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+15);

	printf("长按方向键：加速");

	gotoxy(hOut,FrameX,FrameY);//打印框角

	printf("╔");

	gotoxy(hOut,FrameX+2*Frame_width-2,FrameY);

	printf("╗");

	gotoxy(hOut,FrameX,FrameY+Frame_height);

	printf("╚");

	gotoxy(hOut,FrameX+2*Frame_width-2,FrameY+Frame_height);

	printf("╝");

	for(i=2; i<2*Frame_width-2; i+=2) {

		gotoxy(hOut,FrameX+i,FrameY);

		printf("═");//打印上横框

	}

	for(i=2; i<2*Frame_width-2; i+=2) {

		gotoxy(hOut,FrameX+i,FrameY+Frame_height);

		printf("═");//打印下横框

	}

	for(i=1; i<Frame_height; i++) {

		gotoxy(hOut,FrameX,FrameY+i);

		printf("║");//打印左竖框

	}

	for(i=1; i<Frame_height; i++) {

		gotoxy(hOut,FrameX+2*Frame_width-2,FrameY+i);

		printf("║");//打印右竖框

	}

	gotoxy(hOut,FrameX+Frame_width-5,FrameY-2);//打印游戏名称

	Set_TextColor_Green ();//设置蛇为绿色

	printf("贪吃蛇游戏");

}

/******结束菜单*******************************************************************/

over_game() {

	system("cls");

	printf("\n\n\n\n\n\n\n\n\t\t\t\t游戏结束\n\n\n");

	Sleep(2000);

	return 0;

}

/******菜单信息***************************************************************/

print_information(HANDLE hOut,struct Snake *snake,struct Food *food) {

	gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+1);

	printf("level : %d",snake->count/5+1);//打印游戏等级

	gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+3);

	printf("score : %d",10*snake->count);//打印游戏得分

	gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+5);

	printf("eat food : %d",snake->count);//打印产生食物个数?

	gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+7);

	printf("speed : %dms",snake->speed);//打印游戏速度

	gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+9);

	printf("foodX : %d",food->x);//打印食物的横坐标

	gotoxy(hOut,FrameX+2*Frame_width+3,FrameY+11);

	printf("foodY : %d",food->y);//打印食物的竖坐标

}

/******初始化蛇**********************************************************************/

void init_snake(struct Snake *snake) {

	snake->x[0]=FrameX+2;//初始化蛇的横坐标

	snake->y[0]=FrameY+Frame_height/2;//初始化蛇的竖坐标 

	snake->speed=300;//初始化蛇的速度为300ms

	snake->length=3;//初始化蛇的长度为3节

	snake->count=0;//初始化蛇吃的个数为0

	for(i=1; i<snake->length; i++)

	{

		/* 依次得到蛇身、蛇头的坐标 */

		snake->x[i]=snake->x[i-1]+2;

		snake->y[i]=snake->y[i-1];

	}

}



/******移动蛇*************************************************************************/

void move_snake(HANDLE hOut,struct Snake *snake) {

	gotoxy(hOut,snake->x[0],snake->y[0]);

	printf("  ");/* 清除蛇尾*/

	for(i=1; i<snake->length; i++) {

		/* 后一节的坐标依次取代前一节的坐标 */

		snake->x[i-1]=snake->x[i];

		snake->y[i-1]=snake->y[i];

	}

}



/******打印蛇*************************************************************************/

void print_snake(HANDLE hOut,struct Snake *snake)

{

	for(i=0; i<snake->length; i++)

	{

		gotoxy(hOut,snake->x[i],snake->y[i]);

		if(i==0)

		{

			printf("○");//打印蛇尾

		}

		else if(i==snake->length-1)

		{

			printf("¤");//打印蛇头

		}

		else

		{

			printf("⊙");//打印蛇身

		}

	}

}

/******随机产生食物*******************************************************************/

void get_food(HANDLE hOut,struct Snake *snake,struct Food *food) {

	srand((unsigned)time(NULL));//初始化随机数,srand函数是随机数发生器的初始化函数,防止每次产生的随机数相同 

	while(1) {

		/* 产生食物的条件：1.在游戏窗口内 2.不在蛇的身上 */
		
		food->x = rand() % (Frame_width-1);  //rand()函数是Excel中产生随机数的一个随机函数。返回的随机数是大于等于 0 及小于 1 的均匀分布随机实数

		food->y = rand() % Frame_height;

		if( food->x==0 || food->y==0 ) {

			continue;

		}

		food->x = 2*food->x + FrameX;//得到食物的横坐标

		food->y+=FrameY;//得到食物的竖坐标

		for(i=0; i<snake->length; i++)

		{

			/* 判断食物是否在蛇的身上，如果在蛇身上，则重新产生；否则，打印蛇身 */

			if( food->x==snake->x[i] && food->y==snake->y[i] )

			{

				break;

			}
		}

		if(i==snake->length)

		{

			gotoxy(hOut,food->x,food->y);

			printf("⊙");

			break;

		}

	}

}

/******吃食物***************************************************************************/

void eat_food(HANDLE hOut,struct Snake *snake,struct Food *food)

{

	if( snake->x[snake->length-1]==food->x && snake->y[snake->length-1]==food->y )

	{

		/* 如果蛇头位置与食物位置相同，吃食物 */

		snake->length++;//吃一个食物，蛇身增长一节

		for(i=snake->length-1; i>=1; i--)

		{

			/* 蛇后节坐标依次赋值给蛇前一节的坐标，依次得到蛇身及蛇头的坐标 */

			snake->x[i]=snake->x[i-1];

			snake->y[i]=snake->y[i-1];

		}

		snake->x[0]=a[0];//得到蛇尾移动前的横坐标

		snake->y[0]=a[1];//得到蛇尾移动前的竖坐标

		get_food(hOut,snake,food);//重新产生食物

		snake->count++;//食物的个数增1

		if( snake->count%5==0 )

		{

			/* 当蛇吃Up_level个食物时，速度加快Up_speed毫秒并且升一级 */

			snake->speed-=50;

		}

	}

}



/******判断蛇是否死**************************************************************************/

int if_die(struct Snake *snake)

{

	/* 当蛇头碰到自身时，蛇死 ，返回值为0 */

	for(i=0; i<snake->length-1; i++)

	{

		if( snake->x[snake->length-1]==snake->x[i] && snake->y[snake->length-1]==snake->y[i] )

		{

			return 0;

		}

	}

	return 1;

}

/******登录界面*******************************************************************************/
void regist() {

	system("pause");

	system("cls");

	printf("\n\n\t\t\t欢迎使用贪吃蛇注册系统！\n\n");

	while(1)

	{

		//输入用户名

		printf("\t\t请输入用户名[不能大于10个字符]：");

		scanf("%s",reg_name);

		//判断用户名

		if(strlen(reg_name)<=10)


		{

			while(1)

			{

				//输入密码

				printf("\n\t\t请输入密码[密码长度为八位]：");

				scanf("%s",reg_pwd);

				//判断密码

				if(strlen(reg_pwd)==8)

				{

					printf("\n\n\t\t注册成功，您的用户名是%s,密码是%s\n\n",reg_name,reg_pwd);

					break;

				}

				else

				{

					printf("\n\t\t密码的长度为%d，请重新输入\n",strlen(reg_pwd));

				}

			}

			break;

		} else

		{

			printf("\n\t\t用户名的长度为%d，请重新输入\n\n",strlen(reg_name)); //strlen所作的是一个计数器的工作，它从内存的某个位置（可以是字符串开头，中间某个位置，甚至是某个不确定的内存区域）开始扫描，直到碰到第一个字符串结束符'\0'为止，然后返回计数器值(长度不包含'\0')。

		}

	}
}

//判断是否注册

int judge()

{

	if(strcmp(reg_name,"")==0&&strcmp(reg_pwd,"")==0) //strcmp函数是string compare(字符串比较)的缩写，用于比较两个字符串并根据比较结果返回整数。基本形式为strcmp(str1,str2)，若str1=str2，则返回零；若str1<str2，则返回负数；若str1>str2，则返回正数

	{

		printf("\n\n\t\t您尚未注册，请先注册！\n\n");

		return 0;
	}

	else

	{

		return 1;
	}
}

/******开始游戏*******************************************************************************/

start_game() {

	system("pause");

	system("cls");

	unsigned char ch=77;//定义用于接收键盘输入的字符变量

	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//定义显示器句柄变量

	struct Snake s,*snake=&s;//定义蛇的结构体指针并指向蛇的结构体

	struct Food f,*food=&f;//定义食物的结构体指针并指向食物的结构体

	make_frame();//制作游戏窗口

	init_snake(snake);//初始化蛇

	get_food(hOut,snake,food);//随机产生食物

	while(1)

	{

		print_information(hOut,snake,food);//打印菜单信息

		a[0]=snake->x[0];//记住蛇尾的横坐标

		a[1]=snake->y[0];//记住蛇尾的竖坐标

		j=0;

		if(kbhit())

		{

			/* 判断是否按下键盘，如果按下，ch接收键盘输入 */

			ch=getch(); //getch是一个计算机函数，在windows平台下从控制台无回显地取一个字符

			if(kbhit()) //用于非阻塞地响应键盘输入事件。其中文可译为“键盘敲击”

			{

				/* 如果长按键盘，则加速 */

				Sleep(20);


				j=1;

			}
		}


		switch(ch)

		{

			case 72:

			{

				/* 向上移动 */

				move_snake(hOut,snake);//移动蛇

				snake->y[snake->length-1]-=1;//蛇头的竖坐标向上移，即减1

				break;

			}

			case 80:

			{

				/* 向下移动 */

				move_snake(hOut,snake);//移动蛇

				snake->y[snake->length-1]+=1;//蛇头的竖坐标向下移，即加1

				break;

			}

			case 75:

			{

				/* 向左移动 */

				move_snake(hOut,snake);//移动蛇

				snake->x[snake->length-1]-=2;//蛇头的横坐标向左移，即减2

				break;

			}

			case 77:

			{

				/* 向右移动 */

				move_snake(hOut,snake);//移动蛇

				snake->x[snake->length-1]+=2;//蛇头的横坐标向右移，即加2

				break;

			}

		}

		if( ch==72 && snake->y[snake->length-1]==FrameY)

		{

			return 0;	//如果蛇在上框且向上移动

		}

		if( ch==80 && snake->y[snake->length-1]==FrameY+Frame_height )

		{

			return 0;	//如果蛇在下框且向下移动

		}

		if( ch==75 && snake->x[snake->length-1]==FrameX )

		{

			return 0;	//如果蛇在左框且向左移动

		}

		if( ch==77 && snake->x[snake->length-1]==FrameX+2*Frame_width-2 )

		{

			return 0;	//如果蛇在右框且向右移动

		}

		eat_food(hOut,snake,food);//吃食物

		print_snake(hOut,snake);//打印蛇

		if( if_die(snake)==0 || ch==27 || snake->speed==50 )

		{

			/* 游戏结束条件：1.蛇碰到自身 2.按Esc键 3.速度为50ms */

			gotoxy(hOut,FrameX+Frame_width-2,FrameY+Frame_height/2-1);

			printf("Game Over");

			Sleep(2000);

			break;;

		}

		if(j==0)

		{

			Sleep(snake->speed);//延迟时间

		}

		else

		{

			Sleep(10);

		}

	}

}
//用户登录

void dl()

{

	//定义变量

	system("color 0D");//设置文本为粉红色

	int id;

	while(1)

	{

		system("pause");

		system("cls");

		//输出界面

		printf("                 **********************************                 \n");

		printf("                 **                              **                 \n");

		printf("                 **  欢迎使用贪吃蛇！            **                 \n");

		printf("                 **                              **                 \n");

		printf("                 **********************************                 \n");

		printf("                 -----------祝你使用愉快!----------                 \n");
		//输入功能编号

		printf("                 **********************************                \n");

		printf("                 **                              **                 \n");

		printf("                 *****请选择功能编号：*************                \n");

		printf("                 **                     ***      **                 \n");

		printf("                 **   1.注册账号。     *****     **                \n");

		printf("                 **                     ***      **                 \n");
		
		printf("                 **   2.登录账号。       *       **                \n");

		printf("                 **                      *       **                 \n");

		printf("                 **   0.退出系统。       *       **                \n");
		
		printf("                 **                      *       **                 \n");
		
		printf("                 **********************************                \n");
		
		printf("请输入您的选择："); 

		scanf("%d",&id);

		//判断

		switch(id)

		{

			case 1:

				regist();

				break;

			case 2:

				if(judge()==1)

				{

					return;

				}

				break;

			case 0:

				exit(1);

				break;

			default:

				printf("\n\t\t您输入的功能编号有误，请重新输入！\n");

		}

	}



	system("pause");

	system("cls");

}


int main() {
	
	int start_game();//开始游戏

	int over_game();//结束游戏
	
	dl();


	int d=3;

	int i;

	system("pause");

	system("cls");

	printf(		"	==============================================================================\n");

	printf(		"	==**************************************************************************==\n");

	printf(		"	==                      \\                   /                               ==\n");

	printf(		"	==                       \\                 /                 欢             ==\n");

	printf(		"	==                        \\               /                  迎             ==\n");

	printf(		"	==                 * * * * * * * * * * * * * * * *           来             ==\n");

	printf(		"	==                 * * * * * * * * * * * * * * * *           到             ==\n");

	printf(		"	==                 * *       /          \\      * *           贪             ==\n");

	printf( 	"	==                 * *      /            \\     * *           吃             ==\n");

	printf(     "	==                 * *                         * *           蛇             ==\n");

	printf( 	"	==                 * *         \\  /\\  /        * *                          ==\n");

	printf(		"	==                 * *          \\   \\/         * *                          ==\n");

	printf(		"	==                 * * * * * * * * * * * * * * * *                          ==\n");

	printf(		"	==                 * * * * * * * * * * * * * * * *                          ==\n");

	printf(		"	==                    *                       *                             ==\n");

	printf(		"	==                                                                          ==\n");

	printf(		"	==**************************************************************************==\n");

	printf(		"	******************************************************************************\n");


	printf("\n\n\t\t\t欢迎来到贪吃蛇登录！哔哩哔哩-(゜-゜)つロ乾杯~\n\n");

	//三次登录验证

	for(i=1; i<=3; i++)

	{
		printf("\t\t请输入用户名:");

		scanf("%s",on_name);

		printf("\n\t\t请输入密  码:");

		scanf("%s",on_pwd);

		if(strcmp(reg_name,on_name)==0&&strcmp(reg_pwd,on_pwd)==0)

		{

			printf("\n\n\t\t登录成功，欢迎使用贪吃蛇！\n\n");
			
			start_game();//开始游戏

			over_game();//结束游戏
			
			return 0;
			
		}

		else

		{

			printf("\n\n\t\t登录失败，请重新登录，您还有%d次机会\n\n",3-i);

			d=d--;

			if(d=0)

			{

				return 0;

			}

		}

	}

}

案例二

#include<stdio.h>
#include<conio.h>
#include<time.h>
#include<windows.h>
#include<string.h>
#define up 'w' 
#define down 's' 
#define left 'a' 
#define right 'd' 
#define stop 'p'
void welcome();               //55开始界面

void Finish();                //291结束界面

void creatgraph();            //69围墙打印

void gotoxy(int x, int y);    //111光标跳转，横为X 0,1,2..

void gotoprint(int x, int y); //121跳转打印

void gotodelete(int x, int y);//127跳转删除

void creatfood();             //133食物产生
 
int ClickControl();           //157获取键盘信号

int Judge();                  //270游戏结束判断

void MovingBody();      //172蛇的移动 

void Eating();                //223蛇吃到东西后的操作（伸长）

void ChangeBody(int a,int b); //245蛇的坐标变换,后一个复制前一个STRUCT,a,b为head之前坐标 

 

typedef struct snakes{
	int x;
	int y;
	struct snakes *Next;
}snake;
snake *Head;
snake *tail;
struct Food

{
	int x;
	int y;
}food;
char name[20];
int score=0;
int speed;
char click=1;


void welcome();               //开始界面
void Finish()                //结束界面
{

	system("cls");

	gotoxy(15, 10);

	printf("/**********************************************/");

	gotoxy(15, 20);

	printf("/**********************************************/");

	gotoxy(18, 14);

	printf("GAME   OVER      o(*￣▽￣*)o");

	gotoxy(20, 16);

	printf("Your Score is %d    hiahiahia", score);

	gotoxy(18, 18);



	gotoxy(0, 27);

	system("pause");	
	
}
void creatgraph()            //围墙打印
{
	int i;
	for(i=0;i<58;i+=2)
	{
		gotoprint(i, 0);

		gotoprint(i, 26);
	}
	for(i=1;i<26;i++){
		
		gotoprint(0, i);

		gotoprint(56, i);
		
	}
	gotoxy(63, 10);
	printf("欢迎来到游戏%s",name); 
	gotoxy(63,15);
	printf("您的得分是:%s",score);
	gotoxy(104,29);
	printf("游戏制作者李德旭");
	
	Head = (snake*)malloc(sizeof(snake));

	Head->x = 16;

	Head->y = 15;
	tail=(snake*)malloc(sizeof(snake));
	snake *p=(snake*)malloc(sizeof(snake));
	snake *q=(snake*)malloc(sizeof(snake));
	p->x= 16;
	p->y= 16;
	q->x = 16;
	q->y = 17;
	Head->Next=p;
	p->Next=q;
	q->Next=tail;
	tail->Next=NULL;
	
	
	
}
void gotoxy(int x, int y)    //光标跳转，横为X 0,1,2..
{
	COORD pos;
	HANDLE hOutput;
	pos.X=x;
	 
	pos.Y=y; 
	
	hOutput= GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleCursorPosition(hOutput,pos);
	
	
}
void gotoprint(int x, int y) //跳转打印
{
	gotoxy(x,y);
	printf("■");

	
}
void gotodelete(int x, int y)//跳转删除

{
	gotoxy(x, y);

	printf("  ");
	
}

void creatfood()             //食物产生
{
	srand((int)time(NULL)); 

	lable:

	food.y = rand() % (25 - 1 + 1) + 1;

	food.x = rand() % (54 - 2 + 1) + 2;

	if (food.x % 2 != 0)

	{

		food.x = food.x+1;

	}
  
	snake *judge = Head;

	while (1)  //遍历排除蛇身重复

	{

		if (judge->Next == NULL) break;

		if (food.x == judge->x&&food.y == judge->y)

		{

			goto lable;

		}

		judge = judge->Next;

	}

	gotoxy(food.x, food.y);

	printf("⊙");
	
	
	
}

int ClickControl()           //获取键盘信号
{
	char c;
	
	while (1)

	{

		if (Judge()==0) return 0;

		if(_kbhit())
		{
			click=_getch();
		}
		MovingBody();
		Eating();

		
		
		
	}
	

return 1;

}
	
	
	
	

int Judge()                  //游戏结束判断
{
	if(Head->x==0||Head->y==0||Head->x==56||Head->y==26) 
	{
		Finish();
		return 0;
	}
	snake *p=Head->Next;
	while(p->Next!=NULL){
		if(Head->x==p->x&&Head->y==p->y)
		{
		Finish();
		return 0;
		}	
		p=p->Next;
	}
	return 1;
}
void MovingBody()      //蛇的移动 
{
	int count=0;
	int a=Head->x,b=Head->y;
	snake *p=Head;
	
	while(1)
	{
		if(p->Next==NULL)
		break;
		gotodelete(p->x,p->y);
		
		count++;
		p=p->Next;
		
	} 
	switch(click)
	{
		case up:
		Head->y-=1;	
		ChangeBody(a,b);
		break;
		case down:
		Head->y+=1;
		ChangeBody(a,b);
		break;
		case left:
		Head->x-=2;
		ChangeBody(a,b);
		break;	
		case right:
		Head->x+=2;
		ChangeBody(a,b);
		break;	
	
		
		
	}		
		p=Head;
		while(p->Next!=NULL)
		{
			gotoprint(p->x,p->y);
			p=p->Next;
		}
		p=Head;
		gotoxy(0,28);
	
	if (count<=10)speed=150;
	else if(count>10&& count<=20)speed=100;
	else if(count>20&& count<=40)speed=50;
	else speed=10;
	Sleep(speed);
	
	
}
void Eating()                //蛇吃到东西后的操作（伸长）
{
	
	
	
	if (Head->x == food.x&&Head->y == food.y)

	{

		creatfood();

		snake *_new = (snake*)malloc(sizeof(snake));

		snake *p;

		p = Head;

		while (1)

		{

			if (p->Next->Next == NULL) break;

			p = p->Next;

		}

		p->Next = _new;

		_new->Next = tail;

		score += 10;

		gotoxy(77, 15);

		printf("%d", score);

	}

	
	
	
}
void ChangeBody(int a,int b) //蛇的坐标变换,后一个复制前一个STRUCT,a,b为head之前坐标 
	{
		snake *p=Head->Next; 
		int mid1,mid2,_mid1,_mid2;
		mid1=p->x;
		mid2=p->y; 
		while(1)
		{
			if(p->Next->Next==NULL)
			break;
		_mid1=p->Next->x;
		_mid2=p->Next->y;
		p->Next->x=mid1;
		p->Next->y=mid2;
		mid1 = _mid1;

		mid2 = _mid2; 

		p = p->Next;	
			
			
		}

		p=Head->Next;
		
		p->x = a;

		p->y = b;

	}
int main(){
	creatgraph();
	creatfood();
	if (ClickControl() == 0) return 0;

}

案例三

#include<stdio.h>
#include<time.h>
#include<windows.h>
#include<stdlib.h> 
#define U 1
#define D 2
#define L 3 
#define R 4       //蛇的状态，U：上 ；D：下；L:左 R：右
   
  typedef struct SNAKE //蛇的节点 
  {
      int x;
      int y;
      struct SNAKE *next;
  }snake;
  
  //全局变量//
  int score = 0, add = 10;//总得分与每次吃食物得分。
  int status, sleeptime = 200;//每次运行的时间间隔
  snake *head, *food;//蛇头指针，食物指针
  snake *q;//遍历蛇的时候用到的指针
  int endGamestatus = 0; //游戏结束的情况，1：撞到墙；2：咬到自己；3：主动退出游戏。
  
  //声明全部函数//
  void Pos();//位置函数 
  void creatMap();//创造地图 
  void initSnake();//蛇的初始化 
  void snakeMove();//蛇的移动 
  int biteSelf();//咬自己 
  void createFood();//创造食物 
  void cantCrossWall();//不能穿墙 
  void pause();//暂停 
  void runGame();//控制游戏 
  void initGame();//游戏初始化 
  void endGame();//游戏结束 
  void gameStart();//游戏开始 
  void speeddown();//减速 
  void speedup();//加速 
  void Pos(int x, int y)//设置光标位置
  {
    COORD pos;//定义结构体变量pos 
    HANDLE hOutput;//新建句柄 hOutput 
     pos.X = x;
     pos.Y = y;
     SetConsoleTextAttribute(hOutput,10|1);
     hOutput = GetStdHandle(STD_OUTPUT_HANDLE);//返回标准的输入、输出或错误的设备的句柄，也就是获得输入、输出/错误的屏幕缓冲区的句柄
    SetConsoleCursorPosition(hOutput, pos);
 }
 
 void creatMap()//创建地图
  {
      int i;
      for (i = 0; i<58; i=i+2)//打印上下边框
     {
         Pos(i, 0);
          printf("■");//一个方块占两个位置
        Pos(i, 25);
          printf("■");
      }
    for (i = 0; i<26; i++)//打印左右边框
      {
         Pos(0, i);
         printf("■");
          Pos(56, i);
         printf("■");
      }
  }
  
 void initSnake()//初始化蛇身
 {
     snake *tail;
     int i;
      tail = (snake*)malloc(sizeof(snake));//从蛇尾开始，头插法，以x,y设定开始的位置
      tail->x = 24;
      tail->y = 5;
      tail->next = NULL;
    for (i = 1; i <=3; i++)//初始长度为4
      {
          head = (snake*)malloc(sizeof(snake));
          head->next = tail;		  
          head->x = 24 +2*i;          
          head->y = 5;
          tail= head;
      }
	       
     while (tail!= NULL)//从头到尾，输出蛇身 
     {
        Pos(tail->x, tail->y);
        printf("■");
        tail = tail->next;      
      }    
	    
    
  }
 //
  int biteSelf()//判断是否咬到了自己
  {
     snake *self;
      self = head->next;
      while (self != NULL)
      {
         if (self->x == head->x && self->y == head->y)
         {
             return 1;
         } 
         self = self->next;
     }
    return 0;
 }
 
 void createFood()//随机出现食物
 {
     snake *food_1;
     srand((unsigned)time(NULL));//为了防止每次产生的随机数相同，种子设置为time
     food_1 = (snake*)malloc(sizeof(snake));//初始化food_1 
     food_1->x=rand()%53+2;
    while ((food_1->x % 2)!= 0)    //保证其为偶数，使得食物能与蛇头对齐 
    { 
         food_1->x = food_1->x+1 ;//活动范围 
	}
    
     food_1->y = rand()%23+1; 
     q = head;
     while (q->next !=NULL)
    {
         if (q->x == food_1->x && q->y == food_1->y) //判断蛇身是否与食物重合
         {
            free(food_1);
            createFood();
         }
         q = q->next;
    }
     Pos(food_1->x, food_1->y);
     food = food_1;
     printf("$");
 }
 
 void cantCrossWall()//不能穿墙
 {
    if (head->x == 0 || head->x == 54 || head->y == 0 || head->y == 24)
    {
         endGamestatus = 1;
         endGame();
     }
 }

 void snakeMove()//蛇前进,上U,下D,左L,右R
 {
    snake * nexthead;
     cantCrossWall();
 
    nexthead = (snake*)malloc(sizeof(snake));
     if (status == U)
     {
         nexthead->x = head->x;
         nexthead->y = head->y - 1;
       if (nexthead->x == food->x && nexthead->y == food->y)//如果下一个有食物//
         {
             nexthead->next = head;
             head = nexthead;
             q = head;
             while (q != NULL)
            {
                Pos(q->x, q->y);
                 printf("■");
                 q = q->next;
            }
             score = score + add;
             createFood();
        }
         else                                               //如果没有食物//
         {
            nexthead->next = head;
            head = nexthead;
            q = head;
             while (q->next->next != NULL)
            {
                 Pos(q->x, q->y);
                 printf("■");
                q = q->next;
            }
             Pos(q->next->x, q->next->y);
             printf("  ");
             free(q->next);
            q->next = NULL;
        }
    }
    if (status == D)
     {
         nexthead->x = head->x;
         nexthead->y = head->y + 1;
         if (nexthead->x == food->x && nexthead->y == food->y)  //有食物
         {
             nexthead->next = head;
             head = nexthead;
             q = head;
             while (q != NULL)
             {
                Pos(q->x, q->y);
                 printf("■");
                 q = q->next;
            }
             score = score + add;
             createFood();
         }
        else                               //没有食物
         {
             nexthead->next = head;
             head = nexthead;
             q = head;
             while (q->next->next != NULL)
            {
                Pos(q->x, q->y);
                 printf("■");
                 q = q->next;
             }
             Pos(q->next->x, q->next->y);
             printf("  ");
            free(q->next);
             q->next = NULL;
         }
     }
     if (status == L)
     {
        nexthead->x = head->x - 2;
         nexthead->y = head->y;
         if (nexthead->x == food->x && nexthead->y == food->y)//有食物
        {
             nexthead->next = head;
            head = nexthead;
           q = head;
             while (q != NULL)
             {
                Pos(q->x, q->y);
                 printf("■");
                q = q->next;
             }
             score = score + add;
             createFood();
         }
        else                                //没有食物
         {
             nexthead->next = head;
            head = nexthead;
             q = head;
             while (q->next->next != NULL)
             {
                Pos(q->x, q->y);
                printf("■");
                 q = q->next;
             }
             Pos(q->next->x, q->next->y);
             printf("  ");
             free(q->next);
             q->next = NULL;
        }
    }
    if (status == R)
     {
       nexthead->x = head->x + 2;
         nexthead->y = head->y;
        if (nexthead->x == food->x && nexthead->y == food->y)//有食物
         {
             nexthead->next = head;
            head = nexthead;
            q = head;
             while (q != NULL)
             {
                 Pos(q->x, q->y);
                 printf("■");
                 q = q->next;
            }
             score = score + add;
            createFood();
         }
         else                                         //没有食物
         {
             nexthead->next = head;
             head = nexthead;
             q = head;
           while (q->next->next != NULL)
            {
                 Pos(q->x, q->y);
                printf("■");
                 q = q->next;
             }
            Pos(q->next->x, q->next->y);
            printf("  ");
            free(q->next);
             q->next = NULL;
        }
     }
     if (biteSelf() == 1)       //判断是否会咬到自己
    {
        endGamestatus = 2;
        endGame();
     }
 }

 void pause()//暂停
 {
     while (1)
     {
         Sleep(300);
         if (GetAsyncKeyState(VK_SPACE))
        {
             break;
         }
 
     }
 }
 
 void runGame()//控制游戏        
 {
 
    Pos(64, 15);
     printf("不能穿墙，不能咬到自己\n");
    Pos(64, 16);
     printf("用↑.↓.←.→分别控制蛇的移动.");
     Pos(64, 18);
     printf("ESC ：退出游戏.space：暂停游戏.");
    
     status = R; 
     while (1)
    {
         Pos(64, 10);
        printf("得分：%d  ", score);
         Pos(64, 11);
         printf("每个食物得分：%d分", add);
        if (GetAsyncKeyState(VK_UP) && status != D)//GetAsyncKeyState函数用来判断函数调用时指定虚拟键的状态
         {
             status = U;//如果蛇不是向下前进的时候，按上键，执行向上前进操作
         }
        else if (GetAsyncKeyState(VK_DOWN) && status != U)//如果蛇不是向上前进的时候，按下键，执行向下前进操作
         {
            status = D;
        }
         else if (GetAsyncKeyState(VK_LEFT) && status != R)//如果蛇不是向右前进的时候，按左键，执行向左前进
         {
             status = L;
         }
        else if (GetAsyncKeyState(VK_RIGHT) && status != L)//如果蛇不是向左前进的时候，按右键，执行向右前进
        {
             status = R;
        }
         else if (GetAsyncKeyState(VK_SPACE))
         {
             pause();
         }
        else if (GetAsyncKeyState(VK_ESCAPE))
        {
           endGamestatus = 3;
             break;
        }
         Sleep(300);
         snakeMove();
    }
 }
              
 void initGame()//开始界面
{
     Pos(40, 12); 
     printf("欢迎来到贪食蛇游戏！");
     system("pause");
     system("cls");
     Pos(25, 12);
     printf("用↑.↓.←.→分别控制蛇的移动，\n");
     system("pause");
     system("cls");
 }
 
 void endGame()//结束游戏
 {
 
     system("cls");
     Pos(24, 12);
     if (endGamestatus == 1)
     {
        printf("对不起，您撞到墙了。游戏结束.");
     }
    else if (endGamestatus == 2)
     {
        printf("对不起，您咬到自己了。游戏结束.");
     }
     else if (endGamestatus == 3)
     {
         printf("您的已经结束了游戏。");
     }
     Pos(24, 13);
     printf("您的得分是%d\n", score);
     exit(0);
 }
 
 void gameStart()//游戏初始化
  {
     initGame();
     creatMap();
     initSnake();
     createFood();
  }
 
 int main()
 {  while(1)
     {
	 gameStart();
     runGame();
	 }
     endGame();
     return 0;
}

案例四


#include <stdio.h>

#include <stdlib.h>

#include <Windows.h>//windows编程头文件

#include <time.h>

#include <conio.h>//控制台输入输出头文件

#define SNAKESIZE 100//蛇的身体最大节数

#define MAPWIDTH 118 //宽度

#define MAPHEIGHT 29//高度

//食物的坐标

struct food
{

	int x;

	int y;

}food;

 

//蛇的相关属性

struct snake{

	int speed;//蛇移动的速度

	int len;//蛇的长度

	int x[SNAKESIZE];//组成蛇身的每一个小方块中x的坐标

	int y[SNAKESIZE];//组成蛇身的每一个小方块中y的坐标

 

}snake;

//绘制游戏边框

void drawMap();

//随机生成食物

void createFood();

//按键操作

void keyDown();

//蛇的状态

bool snakeStatus();

//从控制台移动光标

void gotoxy(int x, int y);

int key = 72;//表示蛇移动的方向，72为按下“↑”所代表的数字

 

//用来判断蛇是否吃掉了食物，这一步很重要，涉及到是否会有蛇身移动的效果以及蛇身增长的效果

int changeFlag = 0;

 

int sorce = 0;//记录玩家的得分

//将控制台光标移到（x,y）处

void gotoxy(int x, int y)

{

	COORD coord;

	coord.X = x;

	coord.Y = y;

	SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);

}

void drawMap()

{

	//打印上下边框

	for (int i = 0; i <= MAPWIDTH; i += 2)//i+=2是因为横向占用的是两个位置

	{

		//将光标移动依次到(i,0)处打印上边框

		gotoxy(i, 0);

		printf("■");

		//将光标移动依次到(i,MAPHEIGHT)处打印下边框

		gotoxy(i, MAPHEIGHT);

		printf("■");

	}

 

	//打印左右边框

	for (int i = 1; i < MAPHEIGHT; i++)

	{

		//将光标移动依次到(0,i)处打印左边框

		gotoxy(0, i);

		printf("■");

		//将光标移动依次到(MAPWIDTH, i)处打印左边框

		gotoxy(MAPWIDTH, i);

		printf("■");

	}

 

	//随机生成初试食物

	while (1)

	{

		srand((unsigned int)time(NULL));

		food.x = rand() % (MAPWIDTH - 4) + 2;

		food.y = rand() % (MAPHEIGHT - 2) + 1;

		//生成的食物横坐标的奇偶必须和初试时蛇头所在坐标的奇偶一致，因为一个字符占两个字节位置，若不一致

		//会导致吃食物的时候只吃到一半

		if (food.x % 2 == 0)

			break;

	}

	//将光标移到食物的坐标处打印食物

	gotoxy(food.x, food.y);

	printf("★");

 

	//初始化蛇的属性

	snake.len = 3;

	snake.speed = 200;

 

	//在屏幕中间生成蛇头

	snake.x[0] = MAPWIDTH / 2 + 1;//x坐标为偶数

	snake.y[0] = MAPHEIGHT / 2;

	//打印蛇头

	gotoxy(snake.x[0], snake.y[0]);

	printf("■");

 

	//生成初试的蛇身

	for (int i = 1; i < snake.len; i++)

	{

		//蛇身的打印，纵坐标不变，横坐标为上一节蛇身的坐标值+2

		snake.x[i] = snake.x[i - 1] + 2;

		snake.y[i] = snake.y[i - 1];

		gotoxy(snake.x[i], snake.y[i]);

		printf("■");

	}

	//打印完蛇身后将光标移到屏幕最上方，避免光标在蛇身处一直闪烁

	gotoxy(MAPWIDTH - 2, 0);

	return;

}

void keyDown()

{

	int pre_key = key;//记录前一个按键的方向

	if (_kbhit())//如果用户按下了键盘中的某个键

	{

		fflush(stdin);//清空缓冲区的字符

 

		//getch()读取方向键的时候，会返回两次，第一次调用返回0或者224，第二次调用返回的才是实际值

		key = _getch();//第一次调用返回的不是实际值

		key = _getch();//第二次调用返回实际值

	}

 

	if (changeFlag == 0)

	{

		gotoxy(snake.x[snake.len - 1], snake.y[snake.len - 1]);

		printf("  ");//在蛇尾处输出空格即擦去蛇尾

	}

 

	//将蛇的每一节依次向前移动一节（蛇头除外）

	for (int i = snake.len - 1; i > 0; i--)

	{

		snake.x[i] = snake.x[i - 1];

		snake.y[i] = snake.y[i - 1];

	}

 

	//蛇当前移动的方向不能和前一次的方向相反，比如蛇往左走的时候不能直接按右键往右走

	//如果当前移动方向和前一次方向相反的话，把当前移动的方向改为前一次的方向

	if (pre_key == 72 && key == 80)

		key = 72;

	if (pre_key == 80 && key == 72)

		key = 80;

	if (pre_key == 75 && key == 77)

		key = 75;

	if (pre_key == 77 && key == 75)

		key = 77;

 

	/**

	*控制台按键所代表的数字

	*“↑”：72

	*“↓”：80

	*“←”：75

	*“→”：77

	*/

 

	//判断蛇头应该往哪个方向移动

	switch (key)

	{

	case 75:

		snake.x[0] -= 2;//往左

		break;

	case 77:

		snake.x[0] += 2;//往右

		break;

	case 72:

		snake.y[0]--;//往上

		break;

	case 80:

		snake.y[0]++;//往下

		break;

	}

	//打印出蛇头

	gotoxy(snake.x[0], snake.y[0]);

	printf("■");

	gotoxy(MAPWIDTH - 2, 0);

	//由于目前没有吃到食物，changFlag值为0

	changeFlag = 0;

	return;

}

void createFood()

{

	if (snake.x[0] == food.x && snake.y[0] == food.y)//蛇头碰到食物

	{

		//蛇头碰到食物即为要吃掉这个食物了，因此需要再次生成一个食物

		while (1)

		{

			int flag = 1;

			srand((unsigned int)time(NULL));

			food.x = rand() % (MAPWIDTH - 4) + 2;

			food.y = rand() % (MAPHEIGHT - 2) + 1;

 

			//随机生成的食物不能在蛇的身体上

			for (int i = 0; i < snake.len; i++)

			{

				if (snake.x[i] == food.x && snake.y[i] == food.y)

				{

					flag = 0;

					break;

				}

			}

			//随机生成的食物不能横坐标为奇数，也不能在蛇身，否则重新生成

			if (flag && food.x % 2 == 0)

				break;

		}

 

		//绘制食物

		gotoxy(food.x, food.y);

		printf("★");

 

		snake.len++;//吃到食物，蛇身长度加1

		sorce += 10;//每个食物得10分

		snake.speed -= 5;//随着吃的食物越来越多，速度会越来越快

		changeFlag = 1;//很重要，因为吃到了食物，就不用再擦除蛇尾的那一节，以此来造成蛇身体增长的效果

	}

	return;

}

bool snakeStatus()

{

	//蛇头碰到上下边界，游戏结束

	if (snake.y[0] == 0 || snake.y[0] == MAPHEIGHT)

		return false;

	//蛇头碰到左右边界，游戏结束

	if (snake.x[0] == 0 || snake.x[0] == MAPWIDTH)

		return false;

	//蛇头碰到蛇身，游戏结束

	for (int i = 1; i < snake.len; i++)

	{

		if (snake.x[i] == snake.x[0] && snake.y[i] == snake.y[0])

			return false;

	}

	return true;

}

int main()

{

	drawMap();

	while (1)

	{

		keyDown();

		if (!snakeStatus())

			break;

		createFood();

		Sleep(snake.speed);

	}

 

	gotoxy(MAPWIDTH / 2, MAPHEIGHT / 2);

	printf("Game Over!\n");

	gotoxy(MAPWIDTH / 2, MAPHEIGHT / 2 + 1);

	printf("本次游戏得分为：%d\n", sorce);

	Sleep(5000);

	return 0;

}

案例五

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>//windows编程头文件
#include <time.h>
#include <conio.h>//控制台输入输出头文件

//在一个大的软件工程里面，可能会有多个文件同时包含一个头文件
//当这些文件编译链接成一个可执行文件时，就会出现大量“重定义”的错误
//在头文件中使用#ifndef #define #endif能避免头文件的重定义
 
#ifndef __cplusplus//用于将c++的代码以标准c的形式输出 
 
typedef char bool;
#define false 0
#define true  1
 
#endif

//将光标移动到控制台的(x,y)坐标点处
void gotoxy(int x, int y)
{
	COORD coord;
	coord.X = x;
	coord.Y = y;
	SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);//设置控制台光标的位置 
}
 


#define SNAKESIZE 100//蛇的身体最大节数
#define MAPWIDTH 78//宽度
#define MAPHEIGHT 24//高度

//食物的坐标
struct food{
	int x;
	int y;
}food;
 
//蛇的相关属性
struct snake{
	int speed;//蛇移动的速度
	int len;//蛇的长度
	int x[SNAKESIZE];//组成蛇身的每一个小方块中x的坐标
	int y[SNAKESIZE];//组成蛇身的每一个小方块中y的坐标
 
}snake;

//绘制游戏边框
void drawMap();
//随机生成食物
void createFood();
//按键操作
void keyDown();
//蛇的状态
bool snakeStatus();
//从控制台移动光标
void gotoxy(int x, int y);

int key = 72;//表示蛇移动的方向，72为按下“↑”所代表的数字
 
//用来判断蛇是否吃掉了食物，这一步很重要，涉及到是否会有蛇身移动的效果以及蛇身增长的效果
int changeFlag = 0;
 
int sorce = 0;//记录玩家的得分

int i;
void drawMap()
{
	//打印上下边框
	for (i = 0; i <= MAPWIDTH; i += 2)//i+=2是因为横向占用的是两个位置
	{
		//将光标移动依次到(i,0)处打印上边框
		gotoxy(i, 0);
		printf("■");
		//将光标移动依次到(i,MAPHEIGHT)处打印下边框
		gotoxy(i, MAPHEIGHT);
		printf("■");
	}
 
	//打印左右边框
	for (i = 1; i < MAPHEIGHT; i++)
	{
		//将光标移动依次到(0,i)处打印左边框
		gotoxy(0, i);
		printf("■");
		//将光标移动依次到(MAPWIDTH, i)处打印左边框
		gotoxy(MAPWIDTH, i);
		printf("■");
	}
 
	//随机生成初试食物
	while (1)
	{
		srand((unsigned int)time(NULL));
		food.x = rand() % (MAPWIDTH - 4) + 2;
		food.y = rand() % (MAPHEIGHT - 2) + 1;
		//生成的食物横坐标的奇偶必须和初试时蛇头所在坐标的奇偶一致，因为一个字符占两个字节位置，若不一致
		//会导致吃食物的时候只吃到一半
		if (food.x % 2 == 0)
			break;
	}
	//将光标移到食物的坐标处打印食物
	gotoxy(food.x, food.y);
	printf("*");
 
	//初始化蛇的属性
	snake.len = 3;
	snake.speed = 400;
 
	//在屏幕中间生成蛇头
	snake.x[0] = MAPWIDTH / 2 + 1;//x坐标为偶数
	snake.y[0] = MAPHEIGHT / 2;
	//打印蛇头
	gotoxy(snake.x[0], snake.y[0]);
	printf("■");
 
	//生成初试的蛇身
	for (i = 1; i < snake.len; i++)
	{
		//蛇身的打印，纵坐标不变，横坐标为上一节蛇身的坐标值+2
		snake.x[i] = snake.x[i - 1] + 2;
		snake.y[i] = snake.y[i - 1];
		gotoxy(snake.x[i], snake.y[i]);
		printf("■");
	}
	//打印完蛇身后将光标移到屏幕最上方，避免光标在蛇身处一直闪烁
	gotoxy(MAPWIDTH - 2, 0);
	return;
}

void keyDown()
{
	int pre_key = key;//记录前一个按键的方向
	if (_kbhit())//如果用户按下了键盘中的某个键
	{
		fflush(stdin);//清空缓冲区的字符
 
		//getch()读取方向键的时候，会返回两次，第一次调用返回0或者224，第二次调用返回的才是实际值
		key = _getch();//第一次调用返回的不是实际值
		key = _getch();//第二次调用返回实际值
	}
 
	/*
	*蛇移动时候先擦去蛇尾的一节
	*changeFlag为0表明此时没有吃到食物，因此每走一步就要擦除掉蛇尾，以此营造一个移动的效果
	*为1表明吃到了食物，就不需要擦除蛇尾，以此营造一个蛇身增长的效果
	*/
	if (changeFlag == 0)
	{
		gotoxy(snake.x[snake.len - 1], snake.y[snake.len - 1]);
		printf("  ");//在蛇尾处输出空格即擦去蛇尾
	}
 
	//将蛇的每一节依次向前移动一节（蛇头除外）
	for (i = snake.len - 1; i > 0; i--)
	{
		snake.x[i] = snake.x[i - 1];
		snake.y[i] = snake.y[i - 1];
	}
 
	//蛇当前移动的方向不能和前一次的方向相反，比如蛇往左走的时候不能直接按右键往右走
	//如果当前移动方向和前一次方向相反的话，把当前移动的方向改为前一次的方向
	if (pre_key == 72 && key == 80)
		key = 72;
	if (pre_key == 80 && key == 72)
		key = 80;
	if (pre_key == 75 && key == 77)
		key = 75;
	if (pre_key == 77 && key == 75)
		key = 77;
 
	/**
	*控制台按键所代表的数字
	*“↑”：72
	*“↓”：80
	*“←”：75
	*“→”：77
	*/
 
	//判断蛇头应该往哪个方向移动
	switch (key)
	{
	case 75:
		snake.x[0] -= 2;//往左
		break;
	case 77:
		snake.x[0] += 2;//往右
		break;
	case 72:
		snake.y[0]--;//往上
		break;
	case 80:
		snake.y[0]++;//往下
		break;
	}
	//打印出蛇头
	gotoxy(snake.x[0], snake.y[0]);
	printf("■");
	gotoxy(MAPWIDTH - 2, 0);
	//由于目前没有吃到食物，changFlag值为0
	changeFlag = 0;
	return;
}

void createFood()
{ 
	if (snake.x[0] == food.x && snake.y[0] == food.y)//蛇头碰到食物
	{
		//蛇头碰到食物即为要吃掉这个食物了，因此需要再次生成一个食物
		while (1)
		{
			int flag = 1;
			srand((unsigned int)time(NULL));
			food.x = rand() % (MAPWIDTH - 4) + 2;
			food.y = rand() % (MAPHEIGHT - 2) + 1;
 
			//随机生成的食物不能在蛇的身体上
			for (i = 0; i < snake.len; i++)
			{
				if (snake.x[i] == food.x && snake.y[i] == food.y)
				{
					flag = 0;
					break;
				}
			}
			//随机生成的食物不能横坐标为奇数，也不能在蛇身，否则重新生成
			if (flag && food.x % 2 == 0)
				break;
		}
 
		//绘制食物
		gotoxy(food.x, food.y);
		printf("*");
 
		snake.len++;//吃到食物，蛇身长度加1
		sorce += 10;//每个食物得10分
		snake.speed -= 5;//随着吃的食物越来越多，速度会越来越快
		changeFlag = 1;//很重要，因为吃到了食物，就不用再擦除蛇尾的那一节，以此来造成蛇身体增长的效果
	}
	return;
}

bool snakeStatus()
{
	//蛇头碰到上下边界，游戏结束
	if (snake.y[0] == 0 || snake.y[0] == MAPHEIGHT)
		return false;
	//蛇头碰到左右边界，游戏结束
	if (snake.x[0] == 0 || snake.x[0] == MAPWIDTH)
		return false;
	//蛇头碰到蛇身，游戏结束
	for (i = 1; i < snake.len; i++)
	{
		if (snake.x[i] == snake.x[0] && snake.y[i] == snake.y[0])
			return false;
	}
	return true;
}

int main()
{
    drawMap();
	while (1)
	{
		keyDown();
		if (!snakeStatus())
			break;
		createFood();
		Sleep(snake.speed);
	}
 
	gotoxy(MAPWIDTH / 2, MAPHEIGHT / 2);
	printf("Game Over!\n");
	gotoxy(MAPWIDTH / 2, MAPHEIGHT / 2 + 1);
	printf("本次游戏得分为：%d\n", sorce);
	Sleep(5000);
	return 0;
}

案例六

#include<iostream>
#include<windows.h>
#include<conio.h>
#include<cstdlib>
#include<ctime>
#include<fstream>
#include<cstring> 
#define High 20
#define Width 50 
using namespace std; 
/* -2为食物 & ; -1为边框 # ; 0为 空格 ; 1为蛇头 @; >1为蛇身 * ; */ 

/*全局声明变量*/ 
int Frames[High][Width]={0}; //界面大小
int MoveDirection;//移动方向 1,2,3,4  上下左右 
int Food_x,Food_y;//食物位置 
int MaxGrade;//最高分 
int Grade;//当前分数 
 
/*改善画面函数*/ 
void gotoxy(int x,int y);//光标移动到（x,y）位置 
void HideCursor();	//隐藏光标 

/*功能函数*/ 
void Are_you_ready();//准备界面 
void Initialize();//数据初始化 
void Show(); //显示画面  
void Move();//移动方向 
void KeyPlay();//键盘操作
void SaveMaxGrade();//保存最高分 

/*******主函数*******/
int main()
{
	HideCursor();//隐藏光标
	Initialize();//数据初始化 
	Are_you_ready();//准备界面 
	while(1)
	{
		Show();
		KeyPlay();//键盘操作
		Move();//移动操作
	} 
	SaveMaxGrade();//保存最高分
	return 0;
}
/*******************/ 

/*移动光标*///光标定位 
void gotoxy(int x,int y)//光标移动到（x,y）位置  取代清屏 
{
	HANDLE handle=GetStdHandle(STD_OUTPUT_HANDLE);
	COORD pos;
	pos.X=x;
	pos.Y=y;//该结构体用来记录光标 
	SetConsoleCursorPosition(handle,pos);
}
/*隐藏光标*/
void HideCursor()	 
{
 	CONSOLE_CURSOR_INFO cursor_info = {1, 0}; 
 	SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
}
/*准备界面*/
void Are_you_ready()
{
	
	for(int i=4;i>=1;i--)
		{
			system("cls"); 
			cout<<"\n\n\n\t\t请使用方向键玩蛇！"; 
			if(i==1)
			{
				cout<<"\n\n\n\t\t\tGo!";
				Sleep(200);	
				return ;
			}
			cout<<"\n\n\n\t\t\t"<<i-1;
			Sleep(1000);
		}
} 
/*数据初始化*/
void Initialize()
{ 
	//分数初始化
	ifstream fin("MaxGrade.txt");
	if(!fin)
	{
		cout<<"MaxGrade.txt 文件打开失败！\n";
		//exit(2);
	} 
	fin>>MaxGrade;
	fin.close();
	Grade=0; 
	//边框初始化 # 
	int i,j;
	for(i=0;i<High;i++)
	{
		Frames[i][0]=-1;
		Frames[i][Width-1]=-1;
	}
	for(j=0;j<Width;j++)
	{
		Frames[0][j]=-1;
		Frames[High-1][j]=-1;
	} 
	//蛇初始化 
	for(i=1;i<=5;i++)
	{
		Frames[High/2][Width/2-i]=i; 
	} 
	//移动方向初始化向右 
	MoveDirection = 4;
	//食物位置初始化 
	srand((int)time(NULL));
	do
	{
		Food_x=rand()%(High-5)+4;
		Food_y=rand()%(Width-5)+3;
		//判断食物与蛇是否重合 
		if(Frames[Food_x][Food_y]==0)
		{
			Frames[Food_x][Food_y]=-2;
			break;
		}
	}while(1);
}
/*显示画面*/
void Show() 
{ 
	gotoxy(0,0);//移动光标至初始0,0位置 
	
	for(int i=0;i<High;i++)
	{
		for(int j=0;j<Width;j++)
		{
			if(Frames[i][j]==-1)
			{
				cout<<"#";//-1为边框 # 
				//SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY);
			}
			else if(Frames[i][j]==0)
			{
				cout<<" ";//0为 空格 
			}
			else if(Frames[i][j]==1)
			{
				cout<<"@";//1为蛇头 @ 
			}
			else if(Frames[i][j]>1)
			{
				cout<<"*";//大于1的正整数为蛇身 * 
			   // SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED);//红色 
			}
			else if(Frames[i][j]==-2)
			{
				cout<<"&";//-2为食物 &  
			} 
		}
		cout<<endl;
	}
	if(Grade>MaxGrade)
	{
		cout<<"\n\n\n★当前得分: "<<Grade<<"\t★最高分："<<Grade<<endl;
	}
	else
	{
		cout<<"\n\n\n★当前得分: "<<Grade<<"\t★最高分："<<MaxGrade<<endl;
	}
	cout<<"\n\n\n★按空格暂停\t★按Esc键退出游戏\n";
	if(Grade >= 100&&Grade < 200)
	{
		Sleep(90);
	} 
	else if(Grade >=200 && Grade <300)
	{
		Sleep(50);
	}
	else if(Grade >=300)
	{
		Sleep(10);
	}
	else
	{
		Sleep(200);//刷新速度 
	}
	
} 
/*移动*/
void Move() 
{
	int i,j,max=0;
	int OldTail_i,OldTail_j;//记录旧蛇尾 
	int OldHead_i,OldHead_j;//记录旧蛇头 
	for(i=1;i<High-1;i++)
	{
		for(j=1;j<Width-1;j++)
		{
			if(Frames[i][j]>0)
			{
				//对所有大于0的元素+1 
				Frames[i][j]++;
				//记录旧蛇尾位置 
				if(Frames[i][j]>max)
				{
					max=Frames[i][j];
					OldTail_i=i;
					OldTail_j=j;
				} 
				//记录旧蛇头位置 
				if(Frames[i][j]==2)
				{
					OldHead_i=i;
					OldHead_j=j;	
				} 
			}
		}
	} 
	
	int NewHead_i,NewHead_j; //新蛇头 
	if(MoveDirection==1)//向上 
	{
		NewHead_i=OldHead_i-1;
		NewHead_j=OldHead_j; 
	} 
	if(MoveDirection==2)//向下 
	{
		NewHead_i=OldHead_i+1;
		NewHead_j=OldHead_j;
	} 
	if(MoveDirection==3)//向左 
	{
		NewHead_i=OldHead_i;
		NewHead_j=OldHead_j-1; 
	} 
	if(MoveDirection==4)//向右 
	{
		NewHead_i=OldHead_i;
		NewHead_j=OldHead_j+1;
	} 
	//判断蛇头是否吃到食物
	if(Frames[NewHead_i][NewHead_j]==-2)
	{
		Frames[Food_x][Food_y]=0;//食物变为空格 
		Grade+=10; //分数加10 
		do
		{
		Food_x = rand()%(High-5)+4;
		Food_y = rand()%(Width-5)+3;
		//判断食物与蛇是否重合 
		if(Frames[Food_x][Food_y]==0)
		{
			Frames[Food_x][Food_y] = -2;//产生食物
			break;
		}
		}while(1); 
	}
	else//未吃到长度不变 
	{
		Frames[OldTail_i][OldTail_j] = 0;//最大元素变为0==空格
	}
	//判断蛇头撞到自身或墙壁，游戏失败
	if(Frames[NewHead_i][NewHead_j]>0||Frames[NewHead_i][NewHead_j]==-1)
	{
		system("cls"); 
		cout<<"\n\n\n\t\t\tGame Over!\n\n\n\n\n\n\n";
		Sleep(2000);
		system("cls");
		cout<<"\n\n\n\t\t\t您的分数："<<Grade<<endl;
		if(Grade>MaxGrade) 
		{
			cout<<"\t\t\t！新纪录！\n";
			SaveMaxGrade();//保存最高分
		}
		Sleep(500);
		system("pause");
		exit(0);
	} 
	else//正常操作 
	{
		Frames[NewHead_i][NewHead_j]=1;
	}
	
} 
/*键盘操作*/
void KeyPlay()
{
	if(kbhit())//判断是否有输入
	{
		switch(getch())
		{
		case 224:
			switch(getch())
			{
				case 72:
					if(MoveDirection==1||MoveDirection==2)//下同，判断方向，是否为正在行进方向 
						break;
					MoveDirection = 1;break;//上 
				case 80:
					if(MoveDirection==1||MoveDirection==2)
						break;
					MoveDirection = 2;break;//下 
				case 75:
					if(MoveDirection==3||MoveDirection==4)
						break;
					MoveDirection = 3;break;//左 
				case 77:
					if(MoveDirection==3||MoveDirection==4)
						break;
					MoveDirection = 4;break;//右 
			}
			break;
		case 27://退出（Esc） 
			system("cls");//清屏
			cout<<"\n\n\n\n\t\t\t☆★退出游戏★☆\n\n\n\n";
			exit(0);
		case 32://空格（Space）
			system("cls");//清屏
			cout<<"\n\n\n\n\t\t\t☆★暂停★☆\n\n\n\n";
			cout<<"\n\n\t\t\t";
			system("pause"); 
			system("cls");
			break; 
		}	
	}  
}
/*保存最高分*/
void SaveMaxGrade()
{
	ofstream fout("MaxGrade.txt");
	if(!fout)
	{
		cout<<"MaxGrade.txt 文件打开失败\n";
		exit(2);
	}if(Grade>MaxGrade)
	{
	MaxGrade=Grade;
    }
	fout<<MaxGrade;
	fout.close();
}

案例七

#include <stdio.h>
#include <string.h>
#include <windows.h>
#include <time.h>
#include <conio.h>//预处理命令
#define up 'w'
#define down 's'
#define left 'a'
#define right 'd'
#define stop 'p'

typedef struct Snakes
{
	int x;
	int y;
	struct Snakes *next;
}snake;
snake *head,*tail;
struct Food
{
	int x;
	int y;
}food;

void welcome();//主页面 
void creatgraph();//创建图表
void gotoxy(int x,int y);
void gotoprint(int x,int y);
void creatfood();
int ClickControl();
void Finish();
int Judge();
void MovingBody();
void Eating();
void ChangeBody(int a,int b);
char name[20];
int score=0;
char click=1;
int speed;
int main()
{
	system("color 0B");
	welcome();
	creatgraph();
	creatfood();
	if(ClickControl()==0)
	return 0;
	return 0;
}
void welcome()
{
	gotoxy(35,10);
	printf("/********************************************/");
	gotoxy(35,22);
	printf("/********************************************/");
	gotoxy(40,13);
	printf("\t欢迎来到贪吃蛇游戏");
	gotoxy(35,16);
	printf("\t请在英文输入法中操作，w a s d控制,p暂停");
	gotoxy(40,19);
	printf("\t请输入你的姓名:");
	scanf("%s",name);
	system("cls"); 
}
void creatgraph()//创建图表 
{
	int i;
	for(i=0;i<58;i+=2)
	{
		gotoprint(i,0);
		gotoprint(i,26);
	}
	for(i=1;i<26;i++)
	{
		gotoprint(0,i);
		gotoprint(56,i);
	}
	gotoxy(75,10);
	printf("你好 %s,欢迎你来玩贪吃蛇!",name);
	gotoxy(75,15);
	printf("你的分数是:%d    =￣ ω￣= ",score);
	head = (snake*)malloc(sizeof(snake));
	head->x=16;
	head->y=15;//蛇头坐标 
	tail=(snake*)malloc(sizeof(snake));
	snake *p=(snake*)malloc(sizeof(snake));
	snake *q=(snake*)malloc(sizeof(snake));
	p->x=16;
	p->y=16;//第二个节点 
	q->x=16;
	q->y=17;//第三个节点 
	head->next=p;
	p->next=q;
	q->next=tail;
	tail->next=NULL;//将节点连接起来组成蛇 
}
void gotoprint(int x,int y)//打印 
{
	gotoxy(x,y);
	printf("■");
}
void gotodelete(int x,int y)//删除食物并输入空格 
{
	gotoxy(x,y);
	printf("  ");
}
void gotoxy(int x,int y)//食物出现坐标函数，X表示横坐标，Y表示纵坐标。
{
	COORD pos;//表示一个字符在控制台屏幕上的坐标
	HANDLE hOutput;
	pos.X=x;
	pos.Y=y;
	hOutput = GetStdHandle(STD_OUTPUT_HANDLE);//获得标准输出句柄
	SetConsoleCursorPosition(hOutput, pos);
}
void creatfood()
{
	srand((int)time(NULL));//表示设置一个随机种子，每次运行都能保证随机种子不同 
	lable:
		food.y=rand()%(25-1+1)+1;
		food.x=rand()%(54-2+1)+2;
		if(food.x%2!=0)//保证食物出现位置不出界 
		{
			food.x=food.x+1;
		}
		snake *judge=head;
		while(1)
		{
			if(judge->next==NULL)break;
			if(food.x==judge->x&&food.y==judge->y)
			{
				goto lable;//goto label的label(标签)既可以定义在for循环前面,
		//也可以定义在for循环后面，当跳转到标签地方时，继续执行标签下面的代码
			}
			judge=judge->next;
		}
		gotoxy(food.x,food.y);
		printf("⊙");
}
int ClickControl()
{
	char c;
	while(1)
	{
		if(Judge()==0)
		return 0;
		if(_kbhit())
		{
			click=_getch();
		}
		MovingBody();
		Eating();
	 } 
	 return 1;
}
void MovingBody()
{
	int count=0;
	int a=head->x,b=head->y;
	snake *p=head;
	while(1)
	{
		if(p->next==NULL)
		break;
		gotodelete(p->x,p->y);
		count++;
		p=p->next;
	}
	switch(click)
	{
		case up:
			head->y-=1;
			ChangeBody(a,b);
			break;
		case down:
			head->y+=1;
			ChangeBody(a,b);
			break;
		case left:
			head->x-=2;
			ChangeBody(a,b);
			break;
		case right:
			head->x+=2;
			ChangeBody(a,b);
			break;
		case stop:
			break;
	}
	p=head;
	while(1)
	{
		if(p->next==NULL)
		break;
		gotoprint(p->x,p->y);
		p=p->next;
	}
	p=head;
	gotoxy(0,28);
	if(count<=10)
	speed=150;
	else if(count>10&&count<=20)
	speed=120;//速度调节 
	else if(count>20&&count<=40)
	speed=80;
	else speed =60;
	Sleep(speed);
}
void Eating()
{
	if(head->x==food.x&&head->y==food.y)
	{
		creatfood();
		snake *_new=(snake*)malloc(sizeof(snake));
		snake *p;
		p=head;
		while(1)
		{
			if(p->next->next==NULL)
			break;
			p=p->next;
		}
		p->next=_new;
		_new->next=tail;
		score+=10;
		gotoxy(77,15);
		printf("%d",score);
	}
}
void ChangeBody(int a,int b)
{
	snake *p=head->next;
	int mid1,mid2,_mid1,_mid2;
	mid1=p->x;
	mid2=p->y;
	while(1)
	{
		if(p->next->next==NULL)
		break;
		_mid1=p->next->x;
		_mid2=p->next->y;
		p->next->x=mid1;
		p->next->y=mid2;
		mid1=_mid1;
		mid2=_mid2;
		p=p->next;
	}
	p=head->next;
	{
		p->x=a;
		p->y=b;
	 } 
}
void Finish()
{
	system("cls");
	gotoxy(15,10);
	printf("/*******************************************/");
	gotoxy(15,20);
	printf("/*******************************************/");
	gotoxy(18,14);
	printf("\t\t游戏结束!");
	gotoxy(20,16);
	printf("\t你的分数是 %d     继续努力吧!",score);
	gotoxy(0,27);
	system("pause");
}
int Judge()
{
	if(head->x==0||head->x==56||head->y==0||head->y==26)
	{
		Finish();
		return 0;
	}
	snake *p=head->next;
	while(1)
	{
		if(p->next==NULL)
		break;
		if(head->x==p->x&&head->y==p->y)
		{
			Finish();
			return 0;
		}
		p=p->next;
	}
	return 1;
}

案例八

#include <stdio.h>
#include <Windows.h>//windows编程头文件
#include <time.h>
#include <conio.h>

#ifndef __cplusplus//一般用于将C++代码以标准C形式输出（即以C的形式被调用） 

typedef char bool;
#define false 0
#define true  1
 
#endif

//将光标移动到控制台的(x,y)坐标点处
void gotoxy(int x, int y)
{
	COORD coord;//结构体变量 
	coord.X = x;
	coord.Y = y;
	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); //获得输出设备的句柄
	SetConsoleCursorPosition(hOut, coord);//这是使光标 到（x，y）这个位置的函数.
}
 


#define ss 100//蛇的身体最大节数
#define mw 78//宽度
#define mh 24//高度

//食物的坐标
struct food{
	int x;
	int y;
}food;
 
//蛇的相关属性
struct snake{
	int speed;//蛇移动的速度
	int len;//蛇的长度
	int x[ss];//组成蛇身的每一个小方块中x的坐标
	int y[ss];//组成蛇身的每一个小方块中y的坐标
 
}snake;

//绘制游戏边框
void drawMap();
//随机生成食物
void createFood();
//按键操作
void keyDown();
//蛇的状态
bool snakeStatus();
//从控制台移动光标
int bestsorce();
void gotoxy(int x, int y);


int key = 72;//表示蛇移动的方向，72为按下“↑”所代表的数字
 
//用来判断蛇是否吃掉了食物，这一步很重要，涉及到是否会有蛇身移动的效果以及蛇身增长的效果
int changeFlag = 0;
 
int sorce = 0;//记录玩家的得分

int i;

void zhushi()//打印游戏说明
	{ 
		gotoxy(mw + 8, mh / 2 - 4);
		printf("游戏说明\n");
		gotoxy(mw + 8, mh / 2 -3);
		printf("1.吃东西蛇速度在加快，\n"); 
		gotoxy(mw + 8, mh / 2 - 2);
		printf("2.该游戏通过控制蛇头方向吃东西\n"); 
		gotoxy(mw + 8, mh / 2 -1);
		printf("从而使得蛇变得越来越长。\n");
		gotoxy(mw + 8, mh / 2);
		printf("历史最高分%lld",bestsorce());
	} 
void drawMap()
{
	//打印上下边框
	for (i = 0; i <= mw; i += 2)//i+=2是因为横向占用的是两个位置
	{
		//将光标移动依次到(i,0)处打印上边框
		gotoxy(i, 0);
		printf("■");
		//将光标移动依次到(i,MAPHEIGHT)处打印下边框
		gotoxy(i, mh);
		printf("■");
	}
 
	//打印左右边框
	for (i = 1; i < mh; i++)
	{
		//将光标移动依次到(0,i)处打印左边框
		gotoxy(0, i);
		printf("■");
		//将光标移动依次到(MAPWIDTH, i)处打印左边框
		gotoxy(mw, i);
		printf("■");
	}
 
	//随机生成初试食物
	while (1)
	{
		srand((unsigned int)time(NULL));//随机一个数 
		food.x = rand() % (mw - 4) + 2;
		food.y = rand() % (mh - 2) + 1;
		if (food.x % 2 == 0)
			break;
	}
	//将光标移到食物的坐标处打印食物
	gotoxy(food.x, food.y);
	printf("*");
 
	//初始化蛇的属性
	snake.len = 3;
	snake.speed = 300;
 
	//在屏幕中间生成蛇头
	snake.x[0] = mw / 2 + 1;//x坐标为偶数
	snake.y[0] = mh / 2;
	//打印蛇头
	gotoxy(snake.x[0], snake.y[0]);
	printf("■");
 
	//生成初试的蛇身
	for (i = 1; i < snake.len; i++)
	{
		//蛇身的打印，纵坐标不变，横坐标为上一节蛇身的坐标值+2
		snake.x[i] = snake.x[i - 1] + 2;
		snake.y[i] = snake.y[i - 1];
		gotoxy(snake.x[i], snake.y[i]);
		printf("■");
	}
	gotoxy(mw - 2, 0);	//打印完蛇身后将光标移到屏幕最上方，避免光标在蛇身处一直闪烁
	return;
}

void keyDown()
{
	int w_key = key;//记录前一个按键的方向
	if (kbhit())//如果用户按下了键盘中的某个键,kbhit()只是检测，返回0或1，也就是true或false。
	{
		fflush(stdin);//清空缓冲区的字符
 
		//getch()读取方向键的时候，会返回两次，第一次调用返回0或者224，第二次调用返回的才是实际值
		key = getch();//第一次调用返回的不是实际值
		key = getch();//第二次调用返回实际值
	}
 
	/*
	*蛇移动时候先擦去蛇尾的一节
	*changeFlag为0表明此时没有吃到食物，因此每走一步就要擦除掉蛇尾，以此营造一个移动的效果
	*为1表明吃到了食物，就不需要擦除蛇尾，以此营造一个蛇身增长的效果
	*/
	if (changeFlag == 0)
	{
		gotoxy(snake.x[snake.len - 1], snake.y[snake.len - 1]);
		printf("  ");//在蛇尾处输出空格即擦去蛇尾
	}
 
	//将蛇的每一节依次向前移动一节（蛇头除外）
	for (i = snake.len - 1; i > 0; i--)
	{
		snake.x[i] = snake.x[i - 1];
		snake.y[i] = snake.y[i - 1];
	}
 
	//蛇当前移动的方向不能和前一次的方向相反，比如蛇往左走的时候不能直接按右键往右走
	//如果当前移动方向和前一次方向相反的话，把当前移动的方向改为前一次的方向
	if (w_key == 72 && key == 80)
		key = 72;
	if (w_key == 80 && key == 72)
		key = 80;
	if (w_key == 75 && key == 77)
		key = 75;
	if (w_key == 77 && key == 75)
		key = 77;
 
	/**
	*控制台按键所代表的数字
	*“↑”：72
	*“↓”：80
	*“←”：75
	*“→”：77
	*/
 
	//判断蛇头应该往哪个方向移动
	switch (key)
	{
	case 75:
		snake.x[0] -= 2;//往左
		break;
	case 77:
		snake.x[0] += 2;//往右
		break;
	case 72:
		snake.y[0]--;//往上
		break;
	case 80:
		snake.y[0]++;//往下
		break;
	}
	//打印出蛇头
	gotoxy(snake.x[0], snake.y[0]);
	printf("■");
	gotoxy(mw - 2, 0);
	//由于目前没有吃到食物，changFlag值为0
	changeFlag = 0;
	return;
}

void createFood()
{ 
	if (snake.x[0] == food.x && snake.y[0] == food.y)//蛇头碰到食物
	{
		//蛇头碰到食物即为要吃掉这个食物了，因此需要再次生成一个食物
		while (1)
		{
			int flag = 1;
			srand((unsigned int)time(NULL));
			food.x = rand() % (mw - 4) + 2;
			food.y = rand() % (mh - 2) + 1;
 
			//随机生成的食物不能在蛇的身体上
			for (i = 0; i < snake.len; i++)
			{
				if (snake.x[i] == food.x && snake.y[i] == food.y)
				{
					flag = 0;
					break;
				}
			}
			//随机生成的食物不能横坐标为奇数，否则重新生成
			if (flag && food.x % 2 == 0)
				break;
		}
 
		//绘制食物
		gotoxy(food.x, food.y);
		printf("*");
 
		snake.len++;//吃到食物，蛇身长度加1
		sorce += 10;//每个食物得10分
		snake.speed -= 5;//随着吃的食物越来越多，速度会越来越快
		changeFlag = 1;//很重要，因为吃到了食物，就不用再擦除蛇尾的那一节，以此来造成蛇身体增长的效果
	}
	return;
}
int bestsorce()
{
	static long long int w=0;
	long long int max = 0;
	if(sorce > w) max = sorce;
	else(max = w);
	w = max;
	sorce = 0;
	return max;
}


bool snakeStatus()
{
	//蛇头碰到上下边界，游戏结束
	if (snake.y[0] == 0 || snake.y[0] == mh)
		return false;
	//蛇头碰到左右边界，游戏结束
	if (snake.x[0] == 0 || snake.x[0] == mw)
		return false;
	//蛇头碰到蛇身，游戏结束
	for (i = 1; i < snake.len; i++)
	{
		if (snake.x[i] == snake.x[0] && snake.y[i] == snake.y[0])
			return false;
	}
	return true;
}

void youxi()
{
        system("cls");
		drawMap();
		zhushi();
		while (1)
		{
			keyDown();
			if (!snakeStatus())
				break;
			createFood();
			Sleep(snake.speed);
		}
		gotoxy(mw / 2, mh / 2);
		printf("游戏结束！！！！\n");
		gotoxy(mw / 2, mh / 2 + 1);
		printf("本次游戏得分为：%d\n", sorce);
		
		Sleep(3000);//Sleep()没有返回值，作用是暂停程序，单位是毫秒'
		
}
int main()
{ 
	youxi();
   	do
   	{
   		char i;
   		gotoxy(mw + 8, mh / 2 + 1);
   		printf("1.按 1 键继续 2.按 0 退出 ");
   		gotoxy(mw + 8, mh / 2 + 2);
   		printf("请输入："); 
   		scanf("%d",&i);
   		if(i==0)exit(0);
	 	else(youxi());
	}while(1); 
	return 0;  
}

案例九

#include<stdio.h>
#include<string.h>//√×
#include<stdlib.h>
#include<stdlib.h>
#include<time.h>
#include <windows.h>
#include<conio.h> 
#define h 30
#define k 30
#include<pthread.h>
int num1=0,num2=0;
void gotoxy(int x,int y)
{
	HANDLE handle=GetStdHandle(STD_OUTPUT_HANDLE);
	COORD coord;
	coord.X=x;
	coord.Y=y;
	SetConsoleCursorPosition(handle,coord);
}
void map()//圈上一片地 
{
	for(int i=1;i<h;i++)
	{
		gotoxy(0,i);
		printf("■");
		gotoxy(60,i);
		printf("■");
	} 
	for(int i=0;i<k+1;i++)
	{
		gotoxy(i,0);
		puts("■");
		gotoxy(i,30);
		printf("■");
	}
}
struct snake{
	int sx[50];
	int sy[50];
	int speed;
	int length;
}snake1,snake2;
void firstonesnake()
{
	snake1.speed=1000;
	snake1.length=3;
	snake1.sx[0]=30;
	snake1.sy[0]=15;
	gotoxy(snake1.sx[0],snake1.sy[0]);
	printf("◆");
	for(int i=0;i<snake1.length-1;i++)
	{
		snake1.sy[i+1]=snake1.sy[i]+1;
		snake1.sx[i+1]=snake1.sx[i];
		gotoxy(snake1.sx[i+1],snake1.sy[i+1]);
		printf("■");
	}
}
void firsttwosnake()
{
	snake1.speed=1000;
	snake2.speed=1000;
	snake1.length=3;
	snake2.length=3;
	snake1.sx[0]=14;
	snake1.sy[0]=15;
	snake2.sx[0]=46;
	snake2.sy[0]=15;
	gotoxy(snake1.sx[0],snake1.sy[0]);
	printf("◆");
	gotoxy(snake2.sx[0],snake2.sy[0]);
	printf("◆");
	for(int i=0;i<snake1.length-1;i++)
	{
		snake1.sy[i+1]=snake1.sy[i]+1;
		snake1.sx[i+1]=snake1.sx[i];
		gotoxy(snake1.sx[i+1],snake1.sy[i+1]);
		printf("■");
	}
	for(int i=0;i<snake2.length-1;i++)
	{
		snake2.sy[i+1]=snake2.sy[i]+1;
		snake2.sx[i+1]=snake2.sx[i];
		gotoxy(snake2.sx[i+1],snake2.sy[i+1]);
		printf("■");
	}
}
struct food{
	int x;
	int y;
}food1,food2;
void creat_foodup()//出食物.增加 
{
	srand(time(NULL));
loop:{
	int s1=0,s2=0;
	food1.x=rand()%(k-4)+2;
	food1.y=rand()%(h-2)+1;
	for(int i=0;i<snake1.length;i++)
	{
		if(snake1.sx[i]==food1.x&&snake1.sy[i]==food1.y)
		{
			s1=1;
		}
	}
	for(int i=0;i<snake2.length;i++)
	{
		if(snake2.sx[i]==food1.x&&snake2.sy[i]==food1.y)
		{
			s2=1;
		}
	}
	if(food1.x%2!=0)
	{
		s1=1;
	}
	if(s1==1||s2==1)
	goto loop;
	gotoxy(food1.x,food1.y);
	printf("★");}
}
void creat_foodre()//出食物.减少 
{
	srand(time(NULL));
toop:{
	int s1=0,s2=0;
	food2.x=rand()%(k-4)+2;
	food2.y=rand()%(h-2)+1;
	for(int i=0;i<snake1.length;i++)
	{
		if(snake1.sx[i]==food2.x&&snake1.sy[i]==food2.y)
		{
			s1=1;
		}
	}
	for(int i=0;i<snake2.length;i++)
	{
		if(snake2.sx[i]==food2.x&&snake2.sy[i]==food2.y)
		{
			s2=1;
		}
	}
	if(food1.x==food2.x&&food1.y==food2.y)
	s1=1;
	if(food2.x%2!=0)
	{
		s1=1;
	}
	if(s1==1||s2==1)
	goto toop;
	gotoxy(food2.x,food2.y);
	printf("☆");}
}
void eat_foodone()
{
	if(snake1.sx[0]==food1.x&&snake1.sy[0]==food1.y)
	{
		snake1.length++;
		num1++;
		creat_foodup();
	}
	if(snake1.sx[0]==food2.x&&snake1.sy[0]==food2.y)
	{
		gotoxy(snake1.sx[snake1.length-1],snake1.sy[snake1.length-1]);
		printf("  ");
		snake1.length--;
		num1--;
		creat_foodre();
	}
}
int onesnakedead()//蛇死的条件
{
	int jkl=0;
	for(int i=1;i<snake1.length;i++)
	{
		if(snake1.sx[0]==snake1.sx[i]&&snake1.sy[0]==snake1.sy[i])
		jkl=1;
	}
	if(snake1.sx[0]==60||snake1.sx[0]==0||snake1.sy[0]==0||snake1.sy[0]==30||snake1.length==1||jkl==1)
	{
		gotoxy(29,14);
		printf("你没了");
		gotoxy(27,15);
		printf("再来一局");
		gotoxy(27,16);
		printf("回到菜单"); 
		char aa,bb;
		int dx=36,dy=15;
		while(1)
		{
			gotoxy(dx,dy);
			printf("←");
			bb=getch();
			if(bb!='\r')
			{
				aa=getch();
				gotoxy(dx,dy);
				printf("  ");
				if(aa==72||aa==80)
				{
					switch(aa)
					{
						case 72:dy--;break;
						case 80:dy++;break;
					}
					if(dy>16)
					{
						dy--;
					}
					else if(dy<15)
					{
						dy++;
					}
				}
			}
			else
			return dy;
		}
	}
	else
	return 1;
}
void eat_foodtwo()
{
	if(snake1.sx[0]==food1.x&&snake1.sy[0]==food1.y)
	{
		snake1.length++;
		num1++;
		creat_foodup();
	}
	if(snake1.sx[0]==food2.x&&snake1.sy[0]==food2.y)
	{
		gotoxy(snake1.sx[snake1.length-1],snake1.sy[snake1.length-1]);
		printf("  ");
		snake1.length--;
		num1--;
		creat_foodre();
	}
	if(snake2.sx[0]==food1.x&&snake2.sy[0]==food1.y)
	{
		snake2.length++;
		num2++;
		creat_foodup();
	}
	if(snake2.sx[0]==food2.x&&snake2.sy[0]==food2.y)
	{
		gotoxy(snake2.sx[snake2.length-1],snake2.sy[snake2.length-1]);
		printf("  ");
		snake2.length--;
		num2--;
		creat_foodre();
	}
}


char key2='5';
void keydown2()//处理按键问题
{
	int check2;
	int i='5',j='1',o='2',l='3';
	if (kbhit())
	{
		check2 = getch();
		if(check2==i||check2==j||check2==o||check2==l)
		{
			key2=(char)check2;
		}
	}
	gotoxy(snake2.sx[snake2.length-1],snake2.sy[snake2.length-1]);
	printf("  ");
	for(int i=snake2.length-1;i>0;i--)
	{
		snake2.sx[i]=snake2.sx[i-1];
		snake2.sy[i]=snake2.sy[i-1];
	}
	switch(key2)
	{
		case '5':snake2.sy[0]--;break;
		case '1':snake2.sx[0]--;snake2.sx[0]--;break;
		case '2':snake2.sy[0]++;break;
		case '3':snake2.sx[0]++;snake2.sx[0]++;break;
		default:break;
	}	
}
void gosnake2()//遍历蛇
{
	gotoxy(snake2.sx[0],snake2.sy[0]);
	printf("◆");
	for(int i=1;i<snake2.length;i++)
	{
		gotoxy(snake2.sx[i],snake2.sy[i]);
		printf("■");
	}
}
void *snake222(void *arg)
{
	keydown2();
	gosnake2();
	
}

//蛇2 
///
//蛇1 
char key1={'w'};
void keydown1()//处理按键问题
{
	int check1;
	int z='w',x='W',c='a',v='A',b='s',n='S',m='d',u='D';
	if (kbhit())
	{
		check1 = getch();
		if(check1==z||check1==x||check1==c||check1==v||check1==b||check1==n||check1==m||check1==u) 
		{
			key1=(char)check1;
		}
	}
	gotoxy(snake1.sx[snake1.length-1],snake1.sy[snake1.length-1]);
	printf("  ");
	for(int i=snake1.length-1;i>0;i--)
	{
		snake1.sx[i]=snake1.sx[i-1];
		snake1.sy[i]=snake1.sy[i-1];
	}
	switch(key1)
	{
		case 'w':
		case 'W':snake1.sy[0]--;break;
		case 'a':
		case 'A':snake1.sx[0]--;snake1.sx[0]--;break;
		case 's':
		case 'S':snake1.sy[0]++;break;
		case 'd':
		case 'D':snake1.sx[0]++;snake1.sx[0]++;break;
		default:break;
	}
}
void gosnake1()//遍历蛇
{
	gotoxy(snake1.sx[0],snake1.sy[0]);
	printf("◆");
	for(int i=1;i<snake1.length;i++)
	{
		gotoxy(snake1.sx[i],snake1.sy[i]);
		printf("■");
	}
}
void snake1_speed()//速度变换 
{
	if(snake1.length>4&&snake1.length<8)
	snake1.speed=750;
	if(snake1.length>7&&snake1.length<10)
	snake1.speed=500;
}
void *snake111(void *arg)
{
	keydown1();
	onesnakedead();
	gosnake1();
}
int welcome()
{
	gotoxy(50,10);
	printf("贪吃蛇小游戏");
	gotoxy(52,11);
	printf("单人模式");
	gotoxy(52,12);
	printf("双人模式");
	gotoxy(52,13);
	printf("退出游戏");
	int wx=60,wy=11;
	char aa,bb;
	while(1)
	{
		gotoxy(wx,wy);
		printf("←");
		bb=getch();
		if(bb!='\r')
		{
			aa=getch();
			gotoxy(wx,wy);
			printf("  ");
			if(aa==72||aa==80)
			{
				switch(aa)
				{
					case 72:wy--;break;
					case 80:wy++;break;
				}
				if(wy>13)
				{
					wy--;
				}
				else if(wy<11)
				{
					wy++;
				}
			}
		}
		else
		return wy;
	}
}
int main()
{
	system("color 0b");
	pthread_t th1,th2;
qqq:{
	int choose;
	system("cls");
	choose=welcome();
	if(choose==11)
	{
	ttt:
		{
			num1=0;
			key1='w';
			system("cls");
			int zzz;
			map();
			firstonesnake();
			creat_foodup();
			creat_foodre();
			while(1)
			{
				gotoxy(0,0);
				printf("■");
				gotoxy(32,0);
				printf("■");
				snake1_speed();
				Sleep(snake1.speed);
				keydown1();
				zzz=onesnakedead();
				gotoxy(70,14);
				printf("得分：%d",num1);
				if(zzz==15)
				{
					goto ttt;
				}
				else if(zzz==16)
				{
					goto qqq;
				}
				gosnake1();
				eat_foodone();
			}
		}
	}
	if(choose==12)
	{
	www:{
			system("cls");
	    	map();
			firsttwosnake();
			creat_foodup();
			creat_foodre();
			while(1)
			{
				Sleep(snake1.speed);
				pthread_create(&th1,NULL,snake111,NULL);
				Sleep(100);
				Sleep(snake2.speed);
				pthread_create(&th2,NULL,snake222,NULL);
				eat_foodtwo();
			}
		}
	}
	if(choose==13)
	{
		system("cls");
		gotoxy(52,12);
		printf("bye");
		gotoxy(0,28); 
	}
}
}

ア灬格子衬衫々

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
贪吃蛇小游戏

文章目录案例一案例二案例三案例四案例五案例六案例一#include <stdio.h>#include <windows.h>#include <conio.h>#include <time.h>//游戏窗口#define FrameX 4//游戏窗口左上角的X轴坐标#define FrameY 4//游戏窗口左上角的Y轴坐标#define Frame_height 20//游戏窗口的高度#define Frame_wid
复制链接

扫一扫

专栏目录