c++语言实现贪吃蛇

最新推荐文章于 2024-05-21 14:16:00 发布
最新推荐文章于 2024-05-21 14:16:00 发布
阅读量4.6w 收藏 116
点赞数 29
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35038153/article/details/70244811
版权 
1.完美的贪吃蛇 
#include<windows.h>
#include<time.h>
#include<stdlib.h>
#include<conio.h>
#define N 21
#include<iostream>
using namespace std; 
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 init(int apple[2])//初始化函数（初始化围墙、显示信息、苹果）
{
int i,j;//初始化围墙
int wall[N+2][N+2]={{0}};
for(i=1;i<=N;i++)
{
for(j=1;j<=N;j++)
wall[i][j]=1;
}
color(11);
for(i=0;i<N+2;i++)
{
for(j=0;j<N+2;j++)
{
if(wall[i][j])
cout<<"■";
else cout<<"□" ;
}
cout<<endl;
}
gotoxy(N+3,1);//显示信息
color(20);
cout<<"按 W S A D 移动方向"<<endl;
gotoxy(N+3,2);
color(20);
cout<<"按任意键暂停"<<endl;
gotoxy(N+3,3);
color(20);
cout<<"得分："<<endl;
apple[0]=rand()%N+1;//苹果
apple[1]=rand()%N+1;
gotoxy(apple[0],apple[1]);
color(12);
cout<<"●"<<endl;
}
int main()
{
int i,j;
int** snake=NULL;
int apple[2];
int score=0;
int tail[2];
int len=3;
char ch='p';
srand((unsigned)time(NULL));
init(apple);
snake=(int**)realloc(snake,sizeof(int*)*len);
for(i=0;i<len;i++)
snake[i]=(int*)malloc(sizeof(int)*2);
for(i=0;i<len;i++)
{
snake[i][0]=N/2;
snake[i][1]=N/2+i;
gotoxy(snake[i][0],snake[i][1]);
color(14);
cout<<"★"<<endl;
}
while(1)//进入消息循环
{
tail[0]=snake[len-1][0];
tail[1]=snake[len-1][1];
gotoxy(tail[0],tail[1]);
color(11);
cout<<"■"<<endl;
for(i=len-1;i>0;i--)
{
snake[i][0]=snake[i-1][0];
snake[i][1]=snake[i-1][1];
gotoxy(snake[i][0],snake[i][1]);
color(14);
cout<<"★"<<endl;
}
if(kbhit())
{
gotoxy(0,N+2);
ch=getche();
}
switch(ch)
{
case 'w':snake[0][1]--;break;
case 's':snake[0][1]++;break;
case 'a':snake[0][0]--;break;
case 'd':snake[0][0]++;break;
default: break;
}
gotoxy(snake[0][0],snake[0][1]);
color(14);
cout<<"★"<<endl;
Sleep(abs(200-0.5*score));
if(snake[0][0]==apple[0]&&snake[0][1]==apple[1])//吃掉苹果后蛇分数加1，蛇长加1
{
score++;
len++;
snake=(int**)realloc(snake,sizeof(int*)*len);
snake[len-1]=(int*)malloc(sizeof(int)*2);
apple[0]=rand()%N+1;
apple[1]=rand()%N+1;
gotoxy(apple[0],apple[1]);
color(12);
cout<<"●"<<endl;
gotoxy(N+5,3);
color(20);
cout<<score<<endl;
}
if(snake[0][1]==0||snake[0][1]==N||snake[0][0]==0||snake[0][0]==N)//撞到围墙后失败
{
gotoxy(N/2,N/2);
color(30);
cout<<"失败！！！"<<endl;
for(i=0;i<len;i++)
free(snake[i]);
Sleep(INFINITE);
exit(0);
}
}
return 0;
}

2.有缺陷的贪吃蛇 
#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 //游戏窗口的宽度
//定义全局变量
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);
}
/******设置文本为绿色*****************************************************************/
void Set_TextColor_Green (void)
{ 
 HANDLE Handle = GetStdHandle(STD_OUTPUT_HANDLE);
 
 SetConsoleTextAttribute(Handle, FOREGROUND_INTENSITY | FOREGROUND_GREEN);
}
/******制作游戏窗口******************************************************************/
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("贪吃蛇游戏");
}
/******结束菜单*******************************************************************/
void over_game()
{
 system("cls");
 printf("\n\n\n\n\n\n\n\n\t\t\t\t游戏结束\n\n\n");
 Sleep(2000);
 getch();
}
/******菜单信息***************************************************************/
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));       //初始化随机数
 while(1)
 {/* 产生食物的条件：1.在游戏窗口内 2.不在蛇的身上 */ 
  food->x = rand() % (Frame_width-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;
  }
 }
}
/******穿墙**********************************************************************************/
void through_wall(HANDLE hOut,struct Snake *snake,char ch)
{
 if( ch==72 && snake->y[snake->length-1]==FrameY)
 {
  snake->y[snake->length-1] = FrameY+Frame_height-1; //如果蛇在上框且向上移动，穿墙
 }
 if( ch==80 && snake->y[snake->length-1]==FrameY+Frame_height )
 {
  snake->y[snake->length-1] = FrameY+1;    //如果蛇在下框且向下移动，穿墙
 }
 if( ch==75 && snake->x[snake->length-1]==FrameX )
 {
  snake->x[snake->length-1] = FrameX+2*Frame_width-4; //如果蛇在左框且向左移动，穿墙
 }
 if( ch==77 && snake->x[snake->length-1]==FrameX+2*Frame_width-2 )
 {
  snake->x[snake->length-1] = FrameX+2;    //如果蛇在右框且向右移动，穿墙
 }
}
/******判断蛇是否死**************************************************************************/
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 start_game()
{
 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();
   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;
    }
  }
  through_wall(hOut,snake,ch);    //穿墙   
  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(1000);
  } 
 }
}
int main()
{
 system("color 0D");  //设置文本为粉红色
 start_game();   //开始游戏
 over_game(); 
 return 0;  //结束游戏
}

3.贪吃蛇的简单移动 
#include <stdio.h>
#include <conio.h>
#include <windows.h>

#define BEG_X	2
#define BEG_Y	1
#define WID		20
#define HEI		20

HANDLE hout;
typedef enum {UP, DOWN, LEFT, RIGHT} DIR;
typedef struct Snake_body
{
	COORD pos;//蛇身的位置
	struct Snake_body *next;//下一个蛇身
	struct Snake_body *prev;//前一个蛇身
}SNAKE, *PSNAKE;
PSNAKE head = NULL;//蛇头
PSNAKE tail = NULL;//蛇尾

//画游戏边框的函数
void DrawBorder()
{
	int i, j;
	COORD pos = {BEG_X, BEG_Y};
	for(i = 0; i < HEI; ++i)
	{
		SetConsoleCursorPosition(hout, pos);
		for(j = 0; j < WID; ++j)
		{
			if(i == 0)//第一行
			{
				if(j == 0)
					printf("┏");
				else if(j == WID - 1)
					printf("┓");
				else
					printf("━");
			}
			else if(i == HEI - 1)//最后一行
			{
				if(j == 0)
					printf("┗");
				else if(j == WID - 1)
					printf("┛");
				else
					printf("━");
			}
			else if(j == 0 || j == WID - 1)//第一列或最后一列
				printf("┃");
			else
				printf("  ");
		}
		++pos.Y;
	}	
}

//添加蛇身的函数
void AddBody(COORD pos)
{
	PSNAKE pnew = (PSNAKE)calloc(1, sizeof(SNAKE));
	pnew->pos = pos;
	if(!head)
	{
		head = tail = pnew;
	}
	else
	{
		pnew->next = head;//新创建蛇身的next指向原先的蛇头
		head->prev = pnew;//原先的蛇头的prev指向新创建的蛇身
		head = pnew;//把新创建的蛇身作为新的蛇头
	}
	SetConsoleCursorPosition(hout, head->pos);
	printf("◎");
}

//蛇身移动的函数
void MoveBody(DIR dir)
{
	PSNAKE ptmp;
	COORD pos = head->pos;
	switch(dir)
	{
		case UP:
			if(head->pos.Y > BEG_Y + 1)
				--pos.Y;
			else
				return;
		break;		
		case DOWN:
			if(head->pos.Y < BEG_Y + HEI - 2)
				++pos.Y;
			else
				return;
		break;
		case LEFT:
			if(head->pos.X > BEG_X + 2)
				pos.X -= 2;
			else
				return;
		break;
		case RIGHT:
			if(head->pos.X < BEG_X + (WID - 2) * 2)
				pos.X += 2;
			else 
				return;
		break;
	}
	AddBody(pos);//添加了一个新的蛇头
	ptmp = tail;//保存当前的蛇尾
	tail = tail->prev;
	if(tail)
		tail->next = NULL;
	SetConsoleCursorPosition(hout, ptmp->pos);
	printf("  ");
	free(ptmp);
}


int main()
{
	int ctrl;
	DIR dir = RIGHT;//初始蛇的方向是向右的
	COORD pos = {BEG_X + 2, BEG_Y + HEI / 2};
	system("color 0E");
	system("mode con cols=90 lines=30");
	hout = GetStdHandle(STD_OUTPUT_HANDLE);
	printf("    ------------贪吃蛇的移动------------");
	DrawBorder();
	//自定义几个蛇的身体
	AddBody(pos);
	pos.X += 2;
	AddBody(pos);
	pos.X += 2;
	AddBody(pos);
	pos.X += 2;
	AddBody(pos);
	pos.X += 2;
	AddBody(pos);
	pos.X += 2;
	AddBody(pos);
	pos.X += 2;
	AddBody(pos);
	//控制蛇的移动
	while(ctrl = getch())
	{
		switch(ctrl)
		{
			case 'w':
				if(dir == DOWN)
					continue;
				dir = UP;
				break;
			case 's':
				if(dir == UP)
					continue;
				dir = DOWN;
				break;
			case 'a':
				if(dir == RIGHT)
					continue;
				dir = LEFT;
				break;
			case 'd':
				if(dir == LEFT)
					continue;
				dir = RIGHT;
				break;
			case 'q':
				return 0;
		}
		MoveBody(dir);
	}
	
	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();  
int biteself();  
void createfood();  
void cantcrosswall();  
void snakemove();  
void pause();  
void gamecircle();  
void welcometogame();  
void endgame();  
void gamestart();  
  
void Pos(int x,int y) { //设置光标位置  
    COORD pos;  
    HANDLE hOutput;  
    pos.X=x;  
    pos.Y=y;  
    hOutput=GetStdHandle(STD_OUTPUT_HANDLE);  
    SetConsoleCursorPosition(hOutput,pos);  
}  
  
void creatMap() { //创建地图  
    int i;  
    for(i=0; i<58; i+=2) { //打印上下边框  
        Pos(i,0);  
        printf("■");  
        Pos(i,26);  
        printf("■");  
    }  
    for(i=1; 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<=4; i++) {  
        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));  
    food_1=(snake*)malloc(sizeof(snake));  
    while((food_1->x%2)!=0) {  //保证其为偶数，使得食物能与蛇头对其  
        food_1->x=rand()%52+2;  
    }  
    food_1->y=rand()%24+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==56 ||head->y==0 || head->y==26) {  
        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 gamecircle() { //控制游戏  
  
    Pos(64,15);  
    printf("不能穿墙，不能咬到自己\n");  
    Pos(64,16);  
    printf("用↑.↓.←.→分别控制蛇的移动.");  
    Pos(64,17);  
    printf("F1 为加速，F2 为减速\n");  
    Pos(64,18);  
    printf("ESC ：退出游戏.space：暂停游戏.");  
    Pos(64,20);  
    printf("C语言研究中心 www.clang.cc");  
    status=R;  
    while(1) {  
        Pos(64,10);  
        printf("得分：%d  ",score);  
        Pos(64,11);  
        printf("每个食物得分：%d分",add);  
        if(GetAsyncKeyState(VK_UP) && status!=D) {  
            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;  
        } else if(GetAsyncKeyState(VK_F1)) {  
            if(sleeptime>=50) {  
                sleeptime=sleeptime-30;  
                add=add+2;  
                if(sleeptime==320) {  
                    add=2;//防止减到1之后再加回来有错  
                }  
            }  
        } else if(GetAsyncKeyState(VK_F2)) {  
            if(sleeptime<350) {  
                sleeptime=sleeptime+30;  
                add=add-2;  
                if(sleeptime==350) {  
                    add=1;  //保证最低分为1  
                }  
            }  
        }  
        Sleep(sleeptime);  
        snakemove();  
    }  
}  
  
void welcometogame() { //开始界面  
    Pos(40,12);  
  
    system("title C语言研究中心   www.clang.cc");  
    printf("欢迎来到贪食蛇游戏！");  
    Pos(40,25);  
    printf("              C语言研究中心  www.clang.cc.\n");  
    system("pause");  
    system("cls");  
    Pos(25,12);  
    printf("用↑.↓.←.→分别控制蛇的移动， F1 为加速，2 为减速\n");  
    Pos(25,13);  
    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() { //游戏初始化  
    system("mode con cols=100 lines=30");  
    welcometogame();  
    creatMap();  
    initsnake();  
    createfood();  
}  
  
int main() {  
    gamestart();  
    gamecircle();  
    endgame();  
    return 0;  
}


放肆青春的博客
关注
  • 29
    点赞
  • 踩
  • 116
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
C++入门——实现贪吃蛇游戏
beilizhang的博客
10-04 1万+
参考 《C和C++游戏趣味编程》 贪吃蛇游戏 键盘控制小蛇上、下、左、右移动，迟到食物后长度加1；蛇头碰到自身或窗口边缘，游戏失败 程序框架 #include <graphics.h> #include <conio.h> #include <stdio.h> // 全局变量定义 void startup() // 初始化函数 { } void show() // 绘
C++项目之贪吃蛇
anni5211314的博客
09-23 3905
该项目使用了sqlite库储存用户信息，在开始界面会显示登录，注册和退出三个功能，用户无账号时可注册新账号，账号和密码会存入数据库中，有账号的用户可以直接登录账号，数据库会比对账号和密码以确定用户能否登录成功，用户登录成功后既可以选择游戏难度，游戏难度一共10级，设定的运动速度不同，使用多态对速度划分，可让用户进行更精细的选择，划分选择区间，游戏开始后会根据用户选择的游戏等级进行游戏页面的生成，直到触发游戏结束机制方可退出游戏，退出游戏后返回登陆界面并统计游戏的分
用c++做贪吃蛇
最新发布
2301_78863827的博客
05-21 851
由于蛇是由多块蛇身组成的，机构体数组或者链表来存储蛇蛇在运行过程中，如果吃了食物，那么这块食物就可以看作是新的蛇头了，
用C语言写贪吃蛇
c3872931的博客
07-16 3281
在黑色窗口，输入方向键。需要的C语言图形库以在。
贪吃蛇C语言代码
SGAFPZ的博客
04-18 9万+
贪吃蛇C语言代码贪吃蛇C语言代码 手动贪吃蛇 智能贪吃蛇1.手动贪吃蛇/*蛇越长跑得越快*/ /*作者：SGAFPZ*/ #include <stdio.h> #include <windows.h> #include <stdlib.h> #include <math.h> //#include <unistd.h> #include <conio.h> #include <string.h> #
使用C++编写的简单贪吃蛇游戏
bill_bwdf的博客
12-03 1252
在本文中，我们将学习如何使用C++编写一个简单的贪吃蛇游戏。这个程序包括游戏场景、移动方向、食物和蛇的身体等基本元素。
贪吃蛇小游戏（C语言实现简易版）
weixin_42098648的博客
10-27 3315
大一作品，贪吃蛇小游戏具有菜单功能，难度选择功能，记录功能，暂停功能，缺陷在于不能将游戏分数存入文件中，游戏记录只在当次游戏时有效。
用200行C语言代码写出一个贪吃蛇——1.0(基本版)
weixin_59913110的博客
06-06 5157
总的来说，贪吃蛇这个小游戏涉及到的东西不多，但是对逻辑思维是比较吃基本功的。贪吃蛇，显示给我们看的有三部分：蛇、食物、地图边界。我们可以用一个二维数组来标记这些部分：例如这里我创建了一个 5*10 的二维数组，其中 -1 表食物， 1 表蛇头，2、3、4、5表蛇身，0表示空地。 如果我们想要蛇移动起来，只需要将 蛇尾置0 ，其余部分+1 就行了。另外需要说明的是，我们使用 a s d w 来控制方向，这四个方向对应的整数分别是：3、2、1、0。 5.源文件(函数内部)func.c 6.
c++简易贪吃蛇程序（主打一个入手快，易懂，有成就感嘿嘿）
SWU_ly的博客
11-02 8517
#include <iostream> #include <conio.h> #include <windows.h> #include <cstdio>//C using namespace std; bool gameOver;//布尔判断游戏是否结束 const int width = 40;//画板40*20 const int height = 20; int x, y, fruitx, fruity, score; int tailX[100].
细致的C语言写贪吃蛇教程+详细思路-适合新手附源码
iimT的独立博客
12-15 3万+
#史上最详细的C语言贪吃蛇教程 #前言 在有用C写贪吃蛇的一个想法之后，上网查了几个教程，觉得不是很能看懂。恩。。。或者说不是一下子就能看出来思路+具体怎么实现。所以，我花了早自习的时间想了想如何用最简单的方法实现，晚上大约两个小时写了出来。别说我用两小时装逼，有了思路之后就是码代码和查细节的问题。 PS：这里补充说一下C语言写的控制台游戏的原理是什么，知道的同学直接跳过这一段。实际上就...
C语言程序简单实现贪吃蛇小游戏—不需要graphics.h头文件
菜鸟学C/C++
02-22 2万+
最近学习了一些数据结构的知识，然后试着用链表实现一个小游戏（贪吃蛇），在网上看了一些别人写的代码，然后自己重新改写（以前是一个主函数，现在分成了几个小函数方便查看功能，加了内存释放函数）了。在这里发表自己的 第一篇技术博客，希望大家一起讨论、学习，如果有错误，大家积极指出，这样才会有进步！ snake.h 头文件 #ifndef _SNAKE_H_H_H #define _SNAKE_H_H
C++编写贪吃蛇程序
05-03
使用C语言编写贪吃蛇程序，实现计分，选择游戏难度等功能，用键盘方向键操作。
C++实现贪吃蛇
07-25
使用C/C++实现的贪吃蛇小游戏，在终端显示。仅供学习参考
贪吃蛇C++语言源程序.cpp
02-22
贪吃蛇C++源码，适合初学者参考自学，感兴趣的可以自行下载；贪吃蛇C++源码，适合初学者参考自学，感兴趣的可以自行下载；贪吃蛇C++源码，适合初学者参考自学，感兴趣的可以自行下载
贪吃蛇 C语言 源代码
06-12
贪吃蛇源代码及程序，使用C语言和EasyX图形库开发
【C语言】贪吃蛇游戏的实现（一）
热门推荐
includei的博客
12-28 10万+
最近由于小创需要，捣鼓了一个贪吃蛇游戏，系统由纯C语言开发，VC++6.0编译通过，具体的运行效果如下： 略显简陋的开始界面，图案是我一点一点拼的，因为有\需要转义，所以对齐也花了不少时间，足够繁杂和无聊的工作。 游戏界面如图所示，左侧方框是地图，菱形组成的线是蛇，红色圆点是食物，吃到加分。 游戏结束界面可以选择再来一局或者退出。 系统源码链接：https://download...
用c语言编写贪吃蛇设计步骤,一个C语言编写的贪吃蛇游戏
weixin_42499882的博客
05-18 238
#include#include#include#include#include#define MAXLEN 30#define MAXFOD 6#define eror 1#define ok 0#pragma comment ( lib, "Winmm.lib" )enum direction{left,up,right,down};int pos[MAXLEN][2];int food[MA...
纯C语言实现经典小游戏——贪吃蛇（VS2017）
小红的博客
02-21 8万+
假期无聊第二季，用C语言实现简单经典小游戏——贪吃蛇。特别适合新手熟悉C语言。（完整程序在文章最后！！！） 主要涉及C语言知识点如下： 结构体，函数的定义及调用，指针变量，指针和数组，逻辑表达式，基本的选择和循环语句，头文件的编写等。 可以说是麻雀虽小，五脏俱全，是新手练习C语言的绝佳小项目！ 游戏界面如下： 基本思路： 蛇每吃一个食物蛇身子就增加一格，用WASD控制蛇头的运动，而...
贪吃蛇小游戏C语言实现
conimade的博客
03-08 373
#include &lt;stdio.h&gt;#include &lt;graphics.h&gt; //图形界面头文件#include &lt;time.h&gt;#include &lt;conio.h&gt;#define N 100  //蛇的最大节数//坐标struct Coor{    int x;    int y;};//枚举方向，当一个变量有几种可能的取值时，可以将它定义为枚举...
opencv+c++实现贪吃蛇
05-12
OpenCV 是一个流行的计算机视觉库，可以用于图像处理和计算机视觉应用程序。贪吃蛇是一种经典的小游戏，玩家需要控制一条蛇在屏幕上移动，吃食物，避免碰到墙壁或自身。使用 OpenCV 中的 C 语言实现贪吃蛇游戏如下： 首先，需要编写一些函数来表示贪吃蛇的运动，如对蛇头和蛇身的位置更新，判定碰撞的函数等等。然后，使用 OpenCV 中的函数来生成游戏界面，如画出蛇、食物、墙壁等等。接着，使用循环语句，不断更新贪吃蛇的位置，判定是否吃到了食物，是否碰到了墙壁或自身等等。最后，根据游戏规则，计算出得分，并显示在界面上。 实现贪吃蛇游戏需要较强的编程基础和对 OpenCV 库函数的熟悉程度。除此之外，还需要注意优化程序性能，避免计算量过大导致程序卡顿或崩溃。同时，还需要注意程序的可读性和可扩展性，方便后续改进和维护。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值