c语言贪吃蛇

c语言贪吃蛇

平台用户的互动中精选与c语言贪吃蛇相关的:1、c语言 贪吃蛇 程序 2、C语言的贪吃蛇源代码 3、C语言编写贪吃蛇需要用哪些函数?? 4、贪吃蛇怎么用C语言编写 5、c语言贪吃蛇怎么让蛇自己动起来啊? 6、用c语言编写的贪食蛇游戏 7、求C语言贪吃蛇代码能在DEV上运行通过的贪吃蛇,不要TC上的啊我们老师上课给在DEV我们运行了一次 8、求 贪吃蛇C语言代码 9、c语言贪吃蛇的速度控制程序怎么编 10、c语言贪吃蛇源代码怎么用?
c语言贪吃蛇
平台用户 2018-06-06 16:49:07

下面是精选平台用户互动时的最佳讨论

匿名
匿名


匿名:c语言 贪吃蛇 程序

主要内容: 设计并实现一个类似于手机游戏“贪吃蛇”的程序。一条蛇在密闭的围墙内运动,通过键盘上的四个箭头键控制蛇向上下左右四个方向移动。在围墙内随机出现一个食物,蛇头撞到食物,则表示食物被蛇吃掉,这时蛇的身体长一节,同时加分,接着又出现食物... 主要内容:
设计并实现一个类似于手机游戏“贪吃蛇”的程序。一条蛇在密闭的围墙内运动,通过键盘上的四个箭头键控制蛇向上下左右四个方向移动。在围墙内随机出现一个食物,蛇头撞到食物,则表示食物被蛇吃掉,这时蛇的身体长一节,同时加分,接着又出现食物,等待被蛇吃掉。如果蛇在移动过程中,撞到墙壁、身体交叉或蛇头撞到自己的身体则游戏结束。

基本要求:
课程设计中要求掌握和实现如下功能和方法:
1、掌握基本绘图原理和图形函数的使用方法;
2、掌握游戏中基本的动画实现方法;
3、掌握键盘响应的主要函数和方法;
4、了解游戏中碰撞检测的方法;
5、实现游戏加速功能,包括加速键功能和逐步加速功能;

扩展要求:
1、 实现随机出现障碍物功能;
2、 实现迷宫式围墙;
3、 实现过关式的游戏方式;

文档要求:
系统完成后,要提交格式规范的文档,包含如下内容:
1、 程序的功能;
2、 游戏界面设计和图形函数的使用;
3、 整体设计思路;
4、 程序中的数据结构;
5、 程序中碰撞检测的实现方法;
6、 程序核心算法的流程图;
7、 程序改进的设想;
8、 总结。
1、 程序的功能
设计并实现一个类似于手机游戏“贪吃蛇”的程序。一条蛇在密闭的围墙内运动,通过键盘上的四个箭头键控制蛇向上下左右四个方向移动。在围墙内随机出现一个食物,蛇头撞到食物,则表示食物被蛇吃掉,这时蛇的身体长一节,同时加分,接着又出现食物,等待被蛇吃掉。如果蛇在移动过程中,撞到墙壁或蛇头撞到自己的身体则游戏结束。

2、 游戏界面设计和图形函数的使用
/* 参考指导书中1.3.1和画界面函数部分 */
3、 整体设计思路
/* 参考指导书中1.3.2部分 */
4、 程序中的数据结构
/* 参考指导书中1.3.2部分 */
5、 程序中碰撞检测的实现方法
/* 参考指导书中游戏具体过程函数部分 */
6、 程序核心算法的流程图
/* 参考别人的 囧 */
7、 程序改进的设想
/* 自己瞎琢磨吧! */
8、 总结
通过本次课程设计,强化了我对C语言相关知识的掌握,学会了基本的游戏编程方法,加深了我复杂程序设计的能力,初步掌握了高级语言程序调试技能 ......(此处删节三百字,你就随便编吧!)
下面的解答已被5107人点赞
/* 贪吃蛇程序 by champking */

#define N 200

#include <graphics.h>
#include <stdlib.h>
#include <dos.h>

#define LEFT 0x4b00
#define RIGHT 0x4d00
#define DOWN 0x5000
#define UP 0x4800
#define ESC 0x011b

int i,key;
int score = 0;/*得分*/
int gamespeed = 100000;/*游戏速度自己调整*/

struct Food
{
int x;/*食物的横坐标*/
int y;/*食物的纵坐标*/
int yes;/*判断是否要出现食物的变量*/
}food;/*食物的结构体*/

struct Snake
{
int x[N];
int y[N];
int node;/*蛇的节数*/
int direction;/*蛇移动方向*/
int life;/* 蛇的生命,0活着,1死亡*/
}snake;

void Init(void);/*图形驱动*/
void Close(void);/*图形结束*/
void DrawK(void);/*开始画面*/
void GameOver(void);/*结束游戏*/
void GamePlay(void);/*玩游戏具体过程*/
void PrScore(void);/*输出成绩*/

/*主函数*/
void main(void)
{
Init();/*图形驱动*/
DrawK();/*开始画面*/
GamePlay();/*玩游戏具体过程*/
Close();/*图形结束*/
}

/*图形驱动*/
void Init(void)
{
int gd = DETECT, gm;
initgraph(&gd, &gm, "c:\\tc");
cleardevice();
}
/*开始画面,左上角坐标为(50,40),右下角坐标为(610,460)的围墙*/
void DrawK(void)
{
/*setbkcolor(LIGHTGREEN);*/
setcolor(11);
setlinestyle(SOLID_LINE, 0, THICK_WIDTH);/*设置线型*/

for(i = 50; i <= 600; i += 10)/*画围墙*/
{
rectangle(i, 40, i + 10, 49); /*上边*/
rectangle(i, 451, i + 10, 460);/*下边*/
}

for(i = 40; i <= 450; i += 10)
{
rectangle(50, i, 59, i + 10); /*左边*/
rectangle(601, i, 610, i + 10);/*右边*/
}
}
/*玩游戏具体过程*/
void GamePlay(void)
{
randomize();/*随机数发生器*/
food.yes = 1;/*1表示需要出现新食物,0表示已经存在食物*/
snake.life = 0;/*活着*/
snake.direction = 1;/*方向往右*/
snake.x[0] = 100; snake.y[0] = 100;/*蛇头*/
snake.x[1] = 110; snake.y[1] = 100;
snake.node = 2;/*节数*/
PrScore();/*输出得分*/

while(1)/*可以重复玩游戏,压ESC键结束*/
{
while(!kbhit())/*在没有按键的情况下,蛇自己移动身体*/
{
if(food.yes == 1)/*需要出现新食物*/
{
food.x = rand() % 400 + 60;
food.y = rand() % 350 + 60;

while(food.x % 10 != 0)/*食物随机出现后必须让食物能够在整格内,这样才可以让蛇吃到*/
food.x++;
while(food.y % 10 != 0)
food.y++;
food.yes = 0;/*画面上有食物了*/
}

if(food.yes == 0)/*画面上有食物了就要显示*/
{
setcolor(GREEN);
rectangle(food.x, food.y, food.x + 10, food.y - 10);
}

for(i = snake.node - 1; i > 0; i--)/*蛇的每个环节往前移动,也就是贪吃蛇的关键算法*/
{
snake.x[i] = snake.x[i-1];
snake.y[i] = snake.y[i-1];
}

/*1,2,3,4表示右,左,上,下四个方向,通过这个判断来移动蛇头*/
switch(snake.direction)
{
case 1: snake.x[0] += 10; break;
case 2: snake.x[0] -= 10; break;
case 3: snake.y[0] -= 10; break;
case 4: snake.y[0] += 10; break;
}

for(i = 3; i < snake.node; i++)/*从蛇的第四节开始判断是否撞到自己了,因为蛇头为两节,第三节不可能拐过来*/
{
if(snake.x[i] == snake.x[0] && snake.y[i] == snake.y[0])
{
GameOver();/*显示失败*/
snake.life = 1;
break;
}
}

if(snake.x[0]<55||snake.x[0]>595||snake.y[0]<55||
snake.y[0]>455)/*蛇是否撞到墙壁*/
{
GameOver();/*本次游戏结束*/
snake.life=1; /*蛇死*/
}

if(snake.life == 1)/*以上两种判断以后,如果蛇死就跳出内循环,重新开始*/
break;

if(snake.x[0] == food.x && snake.y[0] == food.y)/*吃到食物以后*/
{
setcolor(0);/*把画面上的食物东西去掉*/
rectangle(food.x, food.y, food.x + 10, food.y - 10);
snake.x[snake.node] =- 20; snake.y[snake.node] =- 20;
/*新的一节先放在看不见的位置,下次循环就取前一节的位置*/
snake.node++;/*蛇的身体长一节*/
food.yes = 1;/*画面上需要出现新的食物*/
score += 10;
PrScore();/*输出新得分*/
}

setcolor(4);/*画出蛇*/

for(i = 0; i < snake.node; i++)
rectangle(snake.x[i], snake.y[i], snake.x[i] + 10,
snake.y[i] - 10);

delay(gamespeed);

setcolor(0);/*用黑色去除蛇的的最后一节*/
rectangle(snake.x[snake.node-1], snake.y[snake.node-1],
snake.x[snake.node-1] + 10, snake.y[snake.node - 1] - 10);
} /*endwhile(!kbhit)*/

if(snake.life == 1)/*如果蛇死就跳出循环*/
break;

key = bioskey(0);/*接收按键*/

if(key == ESC)/*按ESC键退出*/
break;
else
if(key == UP&&snake.direction!=4)
/*判断是否往相反的方向移动*/
snake.direction=3;
else
if(key == RIGHT &&snake.direction != 2)
snake.direction=1;
else
if(key == LEFT && snake.direction != 1)
snake.direction = 2;
else
if(key == DOWN && snake.direction != 3)
snake.direction = 4;
}/*endwhile(1)*/
}

/*游戏结束*/
void GameOver(void)
{
cleardevice();
PrScore();
setcolor(RED);
settextstyle(0, 0, 4);
outtextxy(200, 200, "GAME OVER");
getch();
}

/*输出成绩*/
void PrScore(void)
{
char str[10];
setfillstyle(SOLID_FILL, YELLOW);
bar(50, 15, 220, 35);
setcolor(6);
settextstyle(0,0,2);
sprintf(str, "score:%d", score);
outtextxy(55, 20, str);
}

/*图形结束*/
void Close(void)
{
getch();
closegraph();
}

最后一次编辑时间 推荐于2017-09-18 05:24:38
7302159
7302159


7302159:C语言的贪吃蛇源代码

可以的话追加55分。。我最后的分数~~希望以前自己写过程序的朋友发个给我,时间不多了 我有用!! 邮箱471929895曾道免费资料大全正版 百度很多的那种不用发来了~~
下面的解答已被4014人点赞

 
//******友情提示:如想速度快点,请改小_sleep(500)函数中参数*****  

#include <stdio.h>  
#include <stdlib.h>  
#include <conio.h>  
#include <string.h>  
#include <time.h>  
const int H = 8;   //地图的高  
const int L = 16;  //地图的长  
char GameMap[H][L];   //游戏地图  
int  key;  //按键保存  
int  sum = 1, over = 0;  //蛇的长度, 游戏结束(自吃或碰墙)  
int  dx[4] = {0, 0, -1, 1};  //左、右、上、下的方向  
int  dy[4] = {-1, 1, 0, 0};  
struct Snake   //蛇的每个节点的数据类型  
{  
 int x, y;  //左边位置  
 int now;   //保存当前节点的方向, 0,1,2,3分别为左右上下  
}Snake[H*L];  
const char Shead = '@';  //蛇头  
const char Sbody = '#';  //蛇身  
const char Sfood = '*';  //食物  
const char Snode = '.';  //'.'在地图上标示为空  
void Initial();  //地图的初始化  
void Create_Food(); //在地图上随机产生食物  
void Show();   //刷新显示地图  
void Button();  //取出按键,并判断方向  
void Move();   //蛇的移动  
void Check_Border();  //检查蛇头是否越界  
void Check_Head(int x, int y);   //检查蛇头移动后的位置情况  
int main()   
{  
 Initial();  
 Show();  
 return 0;  
}  
void Initial()  //地图的初始化  
{  
 int i, j;  
 int hx, hy;  
 system("title 贪吃蛇");  //控制台的标题  
 memset(GameMap, '.', sizeof(GameMap));  //初始化地图全部为空'.'  
 system("cls");  
 srand(time(0));   //随机种子  
 hx = rand()%H;    //产生蛇头  
 hy = rand()%L;  
 GameMap[hx][hy] = Shead;  
 Snake[0].x = hx;  Snake[0].y = hy;  
 Snake[0].now = -1;  
 Create_Food();   //随机产生食物  
 for(i = 0; i < H; i++)   //地图显示  
 {   
  for(j = 0; j < L; j++)  
   printf("%c", GameMap[i][j]);  
  printf("\n");  
 }  
     
 printf("\n小小C语言贪吃蛇\n");  
 printf("按任意方向键开始游戏\n");  
    
 getch();   //先接受一个按键,使蛇开始往该方向走  
 Button();  //取出按键,并判断方向  
}  
void Create_Food()  //在地图上随机产生食物  
{  
 int fx, fy;  
 while(1)  
 {  
  fx = rand()%H;  
     fy = rand()%L;  
     
  if(GameMap[fx][fy] == '.')  //不能出现在蛇所占有的位置  
  {   
   GameMap[fx][fy] = Sfood;  
      break;  
  }  
 }  
}  
void Show()  //刷新显示地图  
{  
 int i, j;  
 while(1)  
 {    
  _sleep(500); //延迟半秒(1000为1s),即每半秒刷新一次地图  
  Button();   //先判断按键在移动  
  Move();  
  if(over)  //自吃或碰墙即游戏结束  
  {   
   printf("\n**游戏结束**\n");  
   printf("     >_<\n");  
   getchar();  
      break;  
  }  
  system("cls");   //清空地图再显示刷新吼的地图  
  for(i = 0; i < H; i++)   
  {   
   for(j = 0; j < L; j++)  
    printf("%c", GameMap[i][j]);  
   printf("\n");  
  }  
     
  printf("\n小小C语言贪吃蛇\n");  
  printf("按任意方向键开始游戏\n");  
 }  
}  
void Button()  //取出按键,并判断方向  
{  
 if(kbhit() != 0) //检查当前是否有键盘输入,若有则返回一个非0值,否则返回0  
 {   
  while(kbhit() != 0)  //可能存在多个按键,要全部取完,以最后一个为主  
      key = getch(); //将按键从控制台中取出并保存到key中  
  switch(key)  
  {   //左  
   case 75:  Snake[0].now = 0;  
          break;  
            //右  
            case 77:  Snake[0].now = 1;       
          break;  
            //上  
   case 72:  Snake[0].now = 2;  
          break;  
            //下  
   case 80:  Snake[0].now = 3;  
          break;  
  }  
 }  
}  
void Move()   //蛇的移动  
{  
 int i, x, y;  
    int t = sum;  //保存当前蛇的长度  
 //记录当前蛇头的位置,并设置为空,蛇头先移动  
 x = Snake[0].x;  y = Snake[0].y;  GameMap[x][y] = '.';  
 Snake[0].x = Snake[0].x + dx[ Snake[0].now ];  
 Snake[0].y = Snake[0].y + dy[ Snake[0].now ];  
 Check_Border();   //蛇头是否越界  
 Check_Head(x, y);  //蛇头移动后的位置情况,参数为: 蛇头的开始位置  
 if(sum == t)  //未吃到食物即蛇身移动哦  
    for(i = 1; i < sum; i++)  //要从蛇尾节点向前移动哦,前一个节点作为参照  
 {  
  if(i == 1)   //尾节点设置为空再移动  
   GameMap[ Snake[i].x ][ Snake[i].y ] = '.';  
     
  if(i == sum-1)  //为蛇头后面的蛇身节点,特殊处理  
  {  
   Snake[i].x = x;  
         Snake[i].y = y;  
      Snake[i].now = Snake[0].now;  
  }  
  else   //其他蛇身即走到前一个蛇身位置  
  {  
   Snake[i].x = Snake[i+1].x;  
         Snake[i].y = Snake[i+1].y;  
      Snake[i].now = Snake[i+1].now;  
  }  
      
  GameMap[ Snake[i].x ][ Snake[i].y ] = '#'; //移动后要置为'#'蛇身   
 }  
}  
void Check_Border()  //检查蛇头是否越界  
{  
 if(Snake[0].x < 0 || Snake[0].x >= H  
 || Snake[0].y < 0 || Snake[0].y >= L)  
     over = 1;  
}  
void Check_Head(int x, int y)  //检查蛇头移动后的位置情况  
{  
    
 if(GameMap[ Snake[0].x ][ Snake[0].y ] == '.')  //为空  
  GameMap[ Snake[0].x ][ Snake[0].y ] = '@';  
 else 
  if(GameMap[ Snake[0].x ][ Snake[0].y ] == '*')  //为食物  
  {  
   GameMap[ Snake[0].x ][ Snake[0].y ] = '@';    
   Snake[sum].x = x;   //新增加的蛇身为蛇头后面的那个  
      Snake[sum].y = y;  
      Snake[sum].now = Snake[0].now;  
         GameMap[ Snake[sum].x ][ Snake[sum].y ] = '#';   
   sum++;  
   Create_Food();  //食物吃完了马上再产生一个食物  
  }  
  else 
   over = 1;  
}

最后一次编辑时间 推荐于2017-11-17 20:26:41
平凡的白I光
平凡的白I光


平凡的白I光:C语言编写贪吃蛇需要用哪些函数??

不要源代码,不要思路,只要告诉我需要用到哪些知道就行了,谢谢了。
下面的解答已被9171人点赞
先写个
#include <stdio.h>

int main(void)
{
return 0;
}
然后考虑接下来该怎么填这个空
你的控制:左右上下
状态:整条蛇的全体所占坐标排成一个向量,蛇当前方向
矩形坐标范围
障碍坐标
死亡条件:当蛇头超过矩形坐标范围或者撞击障碍、蛇身
加长条件:吃到食物的时候,蛇全身其他坐标不变,只是尾巴上长了一个。
定时:每当定时时间到,尾巴上的蛇身那一格消失,其他坐标不变,多了一个格,为头部坐标+方向,此为新的蛇头。
再组织成一个程序就可以了
echo '++++++++++[>++++++++++[>+<-]<-]>>-.+++++++.---------.++++++++.>>++++[<++++[<+>-]>-]<<+.-------..' | sed '
s/\([-+]\)/\1\1*p;/g
s/</p--;/g
s/>/p++;/g
s/\./putchar(*p);/g
s/\[/while(*p){/g
s/\]/}/g
1s/^/main(){char*p=calloc(1,6);/
$s/$/}/
/./!d'|gcc -xc - 2>/dev/null&&./a.out
最后一次编辑时间 2015-07-04
°迷岛0RM
°迷岛0RM


°迷岛0RM:贪吃蛇怎么用C语言编写

下面的解答已被2383人点赞
#include <stdio.h>
#include <graphics.h>
#include <stdlib.h>
#include <dos.h> /*引用的库函数*/
#define LEFT 0x4b00
#define RIGHT 0x4d00
#define DOWN 0x5000
#define UP 0x4800
#define ESC 0x011b/*宏定义键名*/
#define N 200
int i,key;
int level;/*游戏等级*/
int score=0;/*得分*/
int gamespeed;/*游戏速度*/
struct Food
{
int x;/*食物的横坐标*/
int y;/*食物的纵坐标*/
int yes;/*判断是否要出现食物的变量*/
}food;/*食物的结构体*/
struct Snake
{
int x[N];
int y[N];
int node;/*蛇的节数*/
int direction;/*蛇移动方向*/
int life;/* 蛇的生命,0活着,1死亡*/
}snake;/*蛇的结构体*/
void Choicelevle(void);/*选择游戏等级*/
void Init(void);/*图形驱动*/
void Close(void);/*图形结束*/
void DRAW(void);/*游戏区域*/
void GameOver(void);/*结束游戏*/
void GamePlay(void);/*玩游戏具体过程*/
void PrScore(void);/*输出成绩*/
/*主函数*/
void main(void)
{
Init();/*图形驱动*/
Choicelevle();/*选择游戏等级*/
DRAW();/*游戏区域*/
GamePlay();/*玩游戏具体过程*/
Close();/*图形结束*/
}

/*图形驱动*/
void Init(void)
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"\\turboc2"); /*初始化图形系统*/
cleardevice(); /*清除图形界面*/
}
/*选择游戏等级*/
void Choicelevle(void)
{char name[20];setcolor(YELLOW);settextstyle(0,0,6);outtextxy(150,150,"Snake");setcolor(GREEN);settextstyle(0,0,1);outtextxy(200,250,"please put in your English name:");outtextxy(200,270,"Choice levle from 1-9.");outtextxy(300,320,"name:yangzilong");/*制作人姓名*/outtextxy(300,350,"number:0902060226");/*制作人学正版全年免费资料大全*/outtextxy(300,380,"class:computer science 0602");/*制作人班级*/getch();printf("please putin your name:");gets(name);printf("please choice levle:");scanf("%d",&level);gamespeed=100000-400*level-300*level*level;if(level>9||level<1){cleardevice(); /*清除图形界面*/setcolor(YELLOW); /*设置字体颜色*/settextstyle(0,0,2); /*设置字体类型*/outtextxy(150,200,"level input error"); /*显示文本*/getch();level=1;}
}
void DRAW(void)
{cleardevice(); /*清屏*/setcolor(2);setlinestyle(SOLID_LINE,0,THICK_WIDTH);/*设置线型*/rectangle(45,45,465,325);}
/*玩游戏具体过程*/
void GamePlay(void)
{setcolor(5);setlinestyle(SOLID_LINE,0,THICK_WIDTH);/*设置线型*/randomize();/*随机数发生器*/food.yes=1;/*1表示需要出现新食物,0表示已经存在食物*/snake.life=0;/*活着*/snake.direction=1;/*方向往右*/snake.x[0]=320;snake.y[0]=240;/*蛇头*/snake.x[1]=330;snake.y[1]=240; /*蛇的第二节位置*/snake.node=3;/*节数*/PrScore();/*输出得分*/while(1)/*可以重复玩游戏,压ESC键结束*/{while(!kbhit())/*在没有按键的情况下,蛇自己移动身体*/{if(food.yes==1)/*需要出现新食物*/{food.x=rand()%360+70;food.y=rand()%250+60;while(food.x%10!=0)/*食物随机出现后必须让食物能够在整格内,这样才可以让蛇吃到*/food.x++;while(food.y%10!=0)food.y++;food.yes=0;/*画面上有食物了*/}
if(food.yes==0)/*画面上有食物了就要显示*/
{
setcolor(GREEN);
rectangle(food.x,food.y,food.x+10,food.y-10);
}
for(i=snake.node-1;i>0;i--)/*蛇的每个环节往前移动*/
{
snake.x[i]=snake.x[i-1];
snake.y[i]=snake.y[i-1];
}
/*1,2,3,4表示右,左,上,下四个方向,通过这个控制来移动蛇头*/
switch(snake.direction)
{
case 1: snake.x[0]+=10;break;
case 2: snake.x[0]-=10;break;
case 3: snake.y[0]-=10;break;
case 4: snake.y[0]+=10;break;
}
for(i=3;i<snake.node;i++)/*从蛇的第四节开始判断是否撞到自己了,因为蛇头为两节,第三节不可能拐过来*/
{
if(snake.x[i]==snake.x[0]&&snake.y[i]==snake.y[0])
{
GameOver();/*显示失败*/
snake.life=1; /*蛇死*/
break;
}
}

/*如果蛇头碰到墙壁,蛇头从对面墙出来*/
if(snake.x[0]<50)
{snake.x[0]=450;/*如果蛇头越过左边界,则从右边界进入*/snake.y[0]=snake.y[0];/*纵坐标不变*/for(i=snake.node-1;i>0;i--){snake.x[i]=snake.x[i-1];snake.y[i]=snake.y[i-1]; /*蛇的其他节数向前推进*/}
{
setfillstyle(SOLID_FILL,0); /*设置填充模式和颜色,0表示黑色*/
bar(50,55,455,315);/*bar是表示填充的范围的函数*/
}
}
else
if(snake.x[0]>450)
{snake.x[0]=50;/*如果蛇头越过右边界,则蛇头从左边界进入*/snake.y[0]=snake.y[0];/*纵坐标不变*/for(i=snake.node-1;i>0;i--){snake.x[i]=snake.x[i-1];snake.y[i]=snake.y[i-1]; /*蛇的其他节数向前推进*/}
{
setfillstyle(SOLID_FILL,0); /*设置填充模式和颜色,0表示黑色*/
bar(50,55,455,315);/*bar是表示填充的范围的函数*/
}
}
else
if(snake.y[0]<60)
{snake.y[0]=320;/*如果蛇头越过上边界,则从下边界进入*/snake.x[0]=snake.x[0];/*横坐标不变*/for(i=snake.node-1;i>0;i--){snake.x[i]=snake.x[i-1];snake.y[i]=snake.y[i-1]; /*蛇的其他节数向前推进*/}
{
setfillstyle(SOLID_FILL,0); /*设置填充模式和颜色,0表示黑色*/
bar(50,55,455,315);/*bar是表示填充的范围的函数*/
}
}
else
if(snake.y[0]>320)
{snake.y[0]=60;/*如果蛇头越过下边界,则从上边界进入*/snake.x[0]=snake.x[0];/*横坐标不变*/for(i=snake.node-1;i>0;i--){snake.x[i]=snake.x[i-1];snake.y[i]=snake.y[i-1]; /*蛇的其他节数向前推进*/}
{
setfillstyle(SOLID_FILL,0); /*设置填充模式和颜色,0表示黑色*/
bar(50,55,455,315);/*bar是表示填充的范围的函数*/
}
}
if(snake.life==1)/*如果蛇死就跳出内循环,重新开始*/
break;
if(snake.x[0]==food.x&&snake.y[0]==food.y)/*吃到食物以后*/
{
setcolor(0);/*把画面上的食物东西去掉*/
rectangle(food.x,food.y,food.x+10,food.y-10); /*用当前线型和颜色画一矩形*/
snake.x[snake.node]=-20;snake.y[snake.node]=-20;
/*新的一节先放在看不见的位置,下次循环就取前一节的位置*/
snake.node++;/*蛇的身体长一节*/
food.yes=1;/*画面上需要出现新的食物*/
score+=10; /*每吃掉一食物,得分累加10分*/
if(score%100==0)
{level++;gamespeed=100000-400*level-300*level*level;/*每吃掉10食物提升一级,速度加快*/PrScore();/*输出新得分*/setcolor(YELLOW); /*设置字体颜色*/settextstyle(0,0,4); /*设置字体类型*/outtextxy(150,200,"LEVEL UP"); /*显示文本*/if(level==10){level=1,gamespeed=100000-400*level-300*level*level;}
delay(6000000);
delay(6000000);
delay(6000000);
delay(6000000);
delay(6000000);
delay(6000000);
delay(6000000);
bar(50,55,455,315);/*bar是表示填充的范围的函数*/
}
PrScore();/*输出新得分*/
}
setcolor(4);/*画出蛇*/
for(i=0;i<snake.node;i++)
rectangle(snake.x[i],snake.y[i],snake.x[i]+10,
snake.y[i]-10);
delay(gamespeed); /*控制游戏速度*/
setcolor(0);
rectangle(snake.x[snake.node-1],snake.y[snake.node-1],
snake.x[snake.node-1]+10,snake.y[snake.node-1]-10);
} /*endwhile(!kbhit)*/ /*用黑色去除蛇的的最后一节*/
if(snake.life==1)/*如果蛇死就跳出循环*/
break;
key=bioskey(0);/*接收按键*/
if(key==ESC)/*按ESC键退出*/
break;
else
if(key==UP&&snake.direction!=4)
/*判断是否往相反的方向移动*/
snake.direction=3;
else
if(key==RIGHT&&snake.direction!=2)
snake.direction=1;
else
if(key==LEFT&&snake.direction!=1)
snake.direction=2;
else
if(key==DOWN&&snake.direction!=3)
snake.direction=4;
}/*endwhile(1)*/
}
/*游戏结束*/
void GameOver(void)
{
cleardevice(); /*清屏*/
PrScore();
setcolor(RED); /*设置字体颜色*/
settextstyle(0,0,4); /*设置字体类型*/
outtextxy(200,200,"GAME OVER"); /*显示文本*/
getch();
}
/*输出成绩及游戏等级*/
void PrScore(void)
{
char str1[20];/*设置字符型数组*/
setfillstyle(SOLID_FILL,0);
bar(50,15,390,35); /*填充矩形框*/
setcolor(6); /*设置文本颜色*/
settextstyle(0,0,2); /*设置数组显示位置*/
sprintf(str1,"score %d level %d",score,level);/*显示数组内容*/
outtextxy(55,20,str1);
setcolor(YELLOW); /*设置字体颜色*/
settextstyle(0,0,2); /*设置字体类型*/
outtextxy(250,400,"EXIT=ESC ");/*显示文本*/
}
void Close(void)
{
closegraph();
}
最后一次编辑时间 推荐于2017-09-15 03:14:25
li455381165
li455381165


li455381165:c语言贪吃蛇怎么让蛇自己动起来啊?

刚学完谭浩强的c语言
尽量详细点
下面的解答已被3683人点赞
死循环+Sleep可以完成这个功能的
比如说我现在定义了一个小方块,让他自动移动
int i,j;
int a[25][80]={0};
//用数组来覆盖整个运行界面
int x=10,y=0;
//定义一个x,y表示方块当前的位置
while(1)
{
//清楚之前的输出信息
system("cls");//这是调用的命令行,作用是清屏
a[x][y]=1;
//数组元素为1就表示在界面上的这个位置显示方块
//在屏幕上相应位置输出方块
for( i = 0; i<25 ; i++)
for( j=0; j<80 ;j++)
if(a[i][j]==0) printf(" ");
//等于0就表示该位置不是方块,输出一个空格
else printf("%c",2);
//否则就输出这个方块
//然后重置这个数组,这个可以和上一个循环合并在一起
for( i = 0; i<25 ; i++)
for( j=0; j<80 ;j++)
a[i][j]=0;
// 更改方块所在的位置
//向上 x=x-1;
//向下 x=x+1;
//向左 y=y-1;
//向右 y=y-1;
//上面的四句保留一句就可以了
//然后休息休息
Sleep(300);
}
基本算法就如代码所示
具体的肯定和你向做的效果不一样
比如说你要控制蛇的方向
那改变位置的时候就需要判断
而且,改变一条蛇和改变一个方块也不一样
不过总体思路是这样子的
仅作参考
注意一点,Sleep函数是window头文件里面的
需要导入window头文件
如果不是Windows系统,请替换为相应的函数
最后一次编辑时间 推荐于2017-09-30 10:23:06
bianchenggaosh
bianchenggaosh


bianchenggaosh:用c语言编写的贪食蛇游戏

麻烦你注释详细点,最好注明每一句话的意思
下面的解答已被4041人点赞
这是一个成功的贪吃蛇代码(c语言编写的),希望你能看懂!慢慢看:
#define N 200
#include <graphics.h>
#include <stdlib.h>
#include <dos.h>
#define LEFT 0x4b00
#define RIGHT 0x4d00
#define DOWN 0x5000
#define UP 0x4800
#define ESC 0x011b
int i,key;
int score=0;/*得分*/
int gamespeed=50000;/*游戏速度自己调整*/
struct Food
{
int x;/*食物的横坐标*/
int y;/*食物的纵坐标*/
int yes;/*判断是否要出现食物的变量*/
}food;/*食物的结构体*/
struct Snake
{
int x[N];
int y[N];
int node;/*蛇的节数*/
int direction;/*蛇移动方向*/
int life;/* 蛇的生命,0活着,1死亡*/
}snake;
void Init(void);/*图形驱动*/
void Close(void);/*图形结束*/
void DrawK(void);/*开始画面*/
void GameOver(void);/*结束游戏*/
void GamePlay(void);/*玩游戏具体过程*/
void PrScore(void);/*输出成绩*/
/*主函数*/
void main(void)
{
Init();/*图形驱动*/
DrawK();/*开始画面*/
GamePlay();/*玩游戏具体过程*/
Close();/*图形结束*/
}
/*图形驱动*/
void Init(void)
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"c:\\tc");
cleardevice();
}
/*开始画面,左上角坐标为(50,40),右下角坐标为(610,460)的围墙*/
void DrawK(void)
{
/*setbkcolor(LIGHTGREEN);*/
setcolor(11);
setlinestyle(SOLID_LINE,0,THICK_WIDTH);/*设置线型*/
for(i=50;i<=600;i+=10)/*画围墙*/
{
rectangle(i,40,i+10,49); /*上边*/
rectangle(i,451,i+10,460);/*下边*/
}
for(i=40;i<=450;i+=10)
{
rectangle(50,i,59,i+10); /*左边*/
rectangle(601,i,610,i+10);/*右边*/
}
}
/*玩游戏具体过程*/
void GamePlay(void)
{
randomize();/*随机数发生器*/
food.yes=1;/*1表示需要出现新食物,0表示已经存在食物*/
snake.life=0;/*活着*/
snake.direction=1;/*方向往右*/
snake.x[0]=100;snake.y[0]=100;/*蛇头*/
snake.x[1]=110;snake.y[1]=100;
snake.node=2;/*节数*/
PrScore();/*输出得分*/
while(1)/*可以重复玩游戏,压ESC键结束*/
{
while(!kbhit())/*在没有按键的情况下,蛇自己移动身体*/
{
if(food.yes==1)/*需要出现新食物*/
{
food.x=rand()%400+60;
food.y=rand()%350+60;
while(food.x%10!=0)/*食物随机出现后必须让食物能够在整格内,这样才可以让蛇吃到*/
food.x++;
while(food.y%10!=0)
food.y++;
food.yes=0;/*画面上有食物了*/
}
if(food.yes==0)/*画面上有食物了就要显示*/
{
setcolor(GREEN);
rectangle(food.x,food.y,food.x+10,food.y-10);
}
for(i=snake.node-1;i>0;i--)/*蛇的每个环节往前移动,也就是贪吃蛇的关键算法*/
{
snake.x[i]=snake.x[i-1];
snake.y[i]=snake.y[i-1];
}
/*1,2,3,4表示右,左,上,下四个方向,通过这个判断来移动蛇头*/
switch(snake.direction)
{
case 1:snake.x[0]+=10;break;
case 2: snake.x[0]-=10;break;
case 3: snake.y[0]-=10;break;
case 4: snake.y[0]+=10;break;
}
for(i=3;i<snake.node;i++)/*从蛇的第四节开始判断是否撞到自己了,因为蛇头为两节,第三节不可能拐过来*/
{
if(snake.x[i]==snake.x[0]&&snake.y[i]==snake.y[0])
{
GameOver();/*显示失败*/
snake.life=1;
break;
}
}
if(snake.x[0]<55||snake.x[0]>595||snake.y[0]<55||
snake.y[0]>455)/*蛇是否撞到墙壁*/
{
GameOver();/*本次游戏结束*/
snake.life=1; /*蛇死*/
}
if(snake.life==1)/*以上两种判断以后,如果蛇死就跳出内循环,重新开始*/
break;
if(snake.x[0]==food.x&&snake.y[0]==food.y)/*吃到食物以后*/
{
setcolor(0);/*把画面上的食物东西去掉*/
rectangle(food.x,food.y,food.x+10,food.y-10);
snake.x[snake.node]=-20;snake.y[snake.node]=-20;
/*新的一节先放在看不见的位置,下次循环就取前一节的位置*/
snake.node++;/*蛇的身体长一节*/
food.yes=1;/*画面上需要出现新的食物*/
score+=10;
PrScore();/*输出新得分*/
}
setcolor(4);/*画出蛇*/
for(i=0;i<snake.node;i++)
rectangle(snake.x[i],snake.y[i],snake.x[i]+10,
snake.y[i]-10);
delay(gamespeed);
setcolor(0);/*用黑色去除蛇的的最后一节*/
rectangle(snake.x[snake.node-1],snake.y[snake.node-1],
snake.x[snake.node-1]+10,snake.y[snake.node-1]-10);
} /*endwhile(!kbhit)*/
if(snake.life==1)/*如果蛇死就跳出循环*/
break;
key=bioskey(0);/*接收按键*/
if(key==ESC)/*按ESC键退出*/
break;
else
if(key==UP&&snake.direction!=4)
/*判断是否往相反的方向移动*/
snake.direction=3;
else
if(key==RIGHT&&snake.direction!=2)
snake.direction=1;
else
if(key==LEFT&&snake.direction!=1)
snake.direction=2;
else
if(key==DOWN&&snake.direction!=3)
snake.direction=4;
}/*endwhile(1)*/
}
/*游戏结束*/
void GameOver(void)
{
cleardevice();
PrScore();
setcolor(RED);
settextstyle(0,0,4);
outtextxy(200,200,"GAME OVER");
getch();
}
/*输出成绩*/
void PrScore(void)
{
char str[10];
setfillstyle(SOLID_FILL,YELLOW);
bar(50,15,220,35);
setcolor(6);
settextstyle(0,0,2);
sprintf(str,"score:%d",score);
outtextxy(55,20,str);
}
/*图形结束*/
void Close(void)
{
getch();
closegraph();
}
最后一次编辑时间 推荐于2017-09-18 11:51:53
爹你爸来了
爹你爸来了


爹你爸来了:求C语言贪吃蛇代码能在DEV上运行通过的贪吃蛇,不要TC上的啊我们老师上课给在DEV我们运行了一次

求C语言贪吃蛇代码能在DEV上运行通过的贪吃蛇,不要TC上的啊我们老师上课给在DEV我们运行了一次跪求跪求😭😭😭😭😭
下面的解答已被7378人点赞

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.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);
    //
    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);

    //
    printf("欢迎来到贪食蛇游戏!");
    Pos(40,25);
    //
    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;
}

最后一次编辑时间 推荐于2017-11-22 20:12:24
lck32578
lck32578


lck32578:求 贪吃蛇C语言代码

求大神给我一份贪吃蛇的代码,不要用到图形库函数的,只用time,stlib,stdio就好了,谢谢!
下面的解答已被6960人点赞
#include <windows.h>
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#include <string.h>
#include <conio.h>
#define N 21

int apple[3],num;
char score[3];
char tail[3];

void gotoxy(int x, int y) //输出坐标
{
COORD pos;
pos.X = x;
pos.Y = y;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
}

void color(int b) //颜色函数
{
HANDLE hConsole = GetStdHandle((STD_OUTPUT_HANDLE)) ;
SetConsoleTextAttribute(hConsole,b) ;
}

int Block(char head[2]) //判断出界
{
if ((head[0] < 1) || (head[0] > N) || (head[1] < 1) || (head[1] > N))
return 1;
return 0;
}

int Eat(char snake[2]) //吃了苹果
{
if ((snake[0] == apple[0]) && (snake[1] == apple[1]))
{
apple[0] = apple[1] = apple[2] = 0;
gotoxy(N+44,10);
color(13);
printf("%d",score[0]*10);
color(11);
return 1;
}
return 0;
}

void Draw(char **snake, int len) //蛇移动
{
if (apple[2])
{
gotoxy(apple[1] * 2, apple[0]);
color(12);
printf("●");
color(11);
}
gotoxy(tail[1] * 2, tail[0]);
if (tail[2])
{
color(num);
printf("★");
color(num);
}
else
printf("■");
gotoxy(snake[0][1] * 2, snake[0][0]);
color(num);
printf("★");
color(num);
putchar('\n');
}

char** Move(char **snake, char dirx, int *len) //控制方向
{
int i, full = Eat(snake[0]);
memcpy(tail, snake[(*len)-1], 2);
for (i = (*len) - 1; i > 0; --i)
memcpy(snake[i], snake[i-1], 2);
switch (dirx)
{
case 'w': case 'W': --snake[0][0]; break;
case 's': case 'S': ++snake[0][0]; break;
case 'a': case 'A': --snake[0][1]; break;
case 'd': case 'D': ++snake[0][1]; break;
default: ;
}
if (full)
{
snake = (char **)realloc(snake, sizeof(char *) * ((*len) + 1));
snake[(*len)] = (char *)malloc(sizeof(char) * 2);
memcpy(snake[(*len)], tail, 2);
++(*len);
++score[0];
if(score[3] < 16)
++score[3];
tail[2] = 1;
}
else
tail[2] = 0;
return snake;
}

void init(char plate[N+2][N+2], char ***snake_x, int *len) //初始化
{
int i, j;
char **snake = NULL;

*len = 3;
score[0] = score[3] =3;
snake = (char **)realloc(snake, sizeof(char *) * (*len));
for (i = 0; i < *len; ++i)
snake[i] = (char *)malloc(sizeof(char) * 2);

for (i = 0; i < 3; ++i)
{
snake[i][0] = N/2 + 1;
snake[i][1] = N/2 + 1 + i;
}

for (i = 1; i <= N; ++i)
for (j = 1; j <= N; ++j)
plate[i][j] = 1;

apple[0] = rand()%N + 1; apple[1] = rand()%N + 1;
apple[2] = 1;

for (i = 0; i < N + 2; ++i)
{
gotoxy(0, i);
for (j = 0; j < N + 2; ++j)
{
switch (plate[i][j])
{
case 0:
color(12);printf("□");color(11); continue;
case 1: printf("■"); continue;
default: ;
}
}
putchar('\n');
}
for (i = 0; i < (*len); ++i)
{
gotoxy(snake[i][1] * 2, snake[i][0]);
printf("★");
}
putchar('\n');
*snake_x = snake;
}

void Manual()
{
gotoxy(N+30,2);
color(10);
printf("按 W S A D 移动方向");
gotoxy(N+30,4);
printf("按 space 键暂停");
gotoxy(N+30,8);
color(11);
printf("历史最高分为: ");
color(12);
gotoxy(N+44,8);
printf("%d",score[1]*10);
color(11);
gotoxy(N+30,12);
printf("你现在得分为: 0");
}

int File_in() //取记录的分数
{
FILE *fp;
if((fp = fopen("C:\\tcs.txt","a+")) == NULL)
{
gotoxy(N+18, N+2);
printf("文件不能打开\n");
exit(0);
}
if((score[1] = fgetc(fp)) != EOF);
else
score[1] = 0;
return 0;
}

int File_out() //存数据
{

FILE *fp;
if(score[1] > score[0])
{gotoxy(10,10);
color(12);
puts("闯关失败 加油耶");
gotoxy(0,N+2);
return 0;
}
if((fp = fopen("C:\\tcs.txt","w+")) == NULL)
{
printf("文件不能打开\n");
exit(0);
}
if(fputc(--score[0],fp)==EOF)
printf("输出失败\n");
gotoxy(10,10);
color(12);
puts("恭喜您打破记录");
gotoxy(0,N+2);
return 0;
}

void Free(char **snake, int len) //释放空间
{
int i;
for (i = 0; i < len; ++i)
free(snake[i]);
free(snake);
}

int main(void)
{
int len;
char ch = 'g';
char a[N+2][N+2] = {{0}};
char **snake;
srand((unsigned)time(NULL));
color(11);
File_in();
init(a, &snake, &len);
Manual();
while (ch != 0x1B) // 按 ESC 结束
{
Draw(snake, len);
if (!apple[2]) {
apple[0] = rand()%N + 1;
apple[1] = rand()%N + 1;
apple[2] = 1;
num++;
if(num>8)
num=0;
}
Sleep(200-score[3]*10);
setbuf(stdin, NULL);
if (kbhit())
{
gotoxy(0, N+2);
ch = getche();
}
snake = Move(snake, ch, &len);
if (Block(snake[0])==1)
{
gotoxy(N+2, N+2);
puts("你输了");
File_out();
Free(snake, len);
getche();
exit(0);
}
}
Free(snake, len);
exit(0);
}

追问

这个在DEV可以编译,但打字出来文件不能打开
而且我想只用三个库文件

最后一次编辑时间 推荐于2017-09-16 17:48:18
小燕子非非
小燕子非非


小燕子非非:c语言贪吃蛇的速度控制程序怎么编

麻烦快些给我答案,谢谢了
下面的解答已被3985人点赞

  1. 可以Sleep函数设置延时来控制贪吃蛇的速度。

    函数名: Sleep
    功 能: 执行挂起一段时间
    用 法: void Sleep(DWORD dwMilliseconds);
    在VC中使用带上头文件
    #include <windows.h>
    ( Sleep函数存放头文件:WinBase.h)
    在gcc编译器中,使用的头文件因gcc版本的不同而不同
    #include <unistd.h>
    Sleep()单位为毫秒,sleep()单位为秒(如果需要更精确可以用usleep单位为微秒)
    返回值
    若进程/线程挂起到参数所指定的时间则返回0,若有信正版全年免费资料大全中断则返回剩余秒数。

  2. 例程:

    / *--------------------snake.h --------------------*/
    #ifndef SNAKE_H
    #define SNAKE_H
     
    #define LEFT 'a'
    #define RIGHT 'd'
    #define DOWN 's'
    #define UP 'w'
    #define ESC 27
     
    #define N 200               /*蛇的最大长度*/
     
    char key;                   /*控制按键*/
     
    struct Food
    {
         int x;                   /*食物的横坐标*/
         int y;                   /*食物的纵坐标*/
         int yes;                 /*判断是否要出现食物的变量*/
    }food;                        /*食物的结构体*/
     
    struct Snake
    {
         int x[N];
         int y[N];
         int node;                /*蛇的节数*/
         int direction;           /*蛇移动方向*/
         int life;                /* 蛇的生命,0活着,1死亡*/
    }snake;
    #endif



    / *--------------------snake.c --------------------*/
    #include <graphics.h>
    #include <stdlib.h>
    #include <conio.h>
    #include <time.h>
    #include <stdio.h>
    #include "snake.h"
     
    int score = 0;
    int gamespeed = 100;                //蛇运行速度
     
    static void Init(void);             /*图形驱动*/
    static void Close(void);            /*图形结束*/
    static void Game_interface(void);   /*游戏界面*/
    static void GameOver(void);         /*结束游戏*/
    static void GamePlay(void);         /*游戏过程*/
    static void PrScore(void);          /*输出成绩*/
     
    /*主函数*/
    int main(void)
    {
         Init();                
         Game_interface();                
         GamePlay();             
         Close();                
         return 0;
    }
     
    /*图形驱动*/
    static void Init(void)
    {
        int gd=9,gm=2;
     
        initgraph(&gd,&gm," ");
        cleardevice();
    }
     
    /* 开始画面,左上角坐标为(50,40),右下角坐标为(610,460)的围墙 */
    static void Game_interface(void)
    {
         int i;
     
         setcolor(LIGHTCYAN);                           /*setbkcolor(LIGHTGREEN);*/
         setlinestyle(PS_SOLID,0,1);                    /*设置线型*/
         for(i=50;i<=600;i+=10)                          /*画边框*/
         {
             rectangle(i,40,i+10,49);                   /*上边框*/
             rectangle(i,451,i+10,460);                 /*下边框*/
         }
         for(i=40;i<=450;i+=10)
         {
             rectangle(50,i,59,i+10);                   /*左边框*/
             rectangle(601,i,610,i+10);                 /*右边框*/
         }
    }
     
    /* 游戏主函数 */
    static void GamePlay(void)
    {
         int i;
          
         srand(time(NULL));                             /*随机数发生器*/
         food.yes = 1;                                  /*1表示需要出现新食物,0表示已经存在食物*/
         snake.life = 0;                                /*活着*/
         snake.direction = 1;                           /*方向往右*/
         snake.x[0] = 100;
         snake.y[0] = 100;                             
         snake.x[1] = 110;
         snake.y[1] = 100;
         snake.node = 2;                                /*节数*/
     
         PrScore();                                     /*输出得分*/
         while(1)                                       /*可以重复玩游戏,压ESC键结束*/
         {
             while( !kbhit() )                          /*在没有按键的情况下,蛇自己移动*/
             {
                 if(food.yes == 1)                      /*需要出现新食物*/
                 {
                     food.x = rand()%400 + 60;
                     food.y = rand()%350 + 60;
                     while(food.x%10 != 0)              /*食物随机出现后必须让食物能够在整格内,这样才可以让蛇吃到*/
                         food.x++;
                     while(food.y%10 != 0)
                         food.y++;
                     food.yes = 0;                      /*画面上有食物了*/
                 }
                 if(food.yes == 0)                      /*画面上有食物了就要显示*/
                 {
                     setcolor(GREEN);
                     rectangle(food.x,food.y,food.x + 10,food.y - 10);
                 }
     
     
                 for(i=snake.node-1;i>0;i--)          /*蛇的每个环节往前移动,也就是贪吃蛇的关键算法*/
                 {
                     snake.x[i] = snake.x[i-1];
                     snake.y[i] = snake.y[i-1];
                 }
                 /*1,2,3,4表示右,左,上,下四个方向,通过这个判断来移动蛇头*/
                 switch(snake.direction)
                 {
                     case 1:
                         snake.x[0] += 10;
                         break;
                     case 2:
                         snake.x[0] -= 10;
                         break;
                     case 3:
                         snake.y[0] -= 10;
                         break;
                     case 4:
                         snake.y[0] += 10;
                         break;
                 }
                 /* 从蛇的第四节开始判断是否撞到自己 */
                 for(i=3;i<snake.node;i++)
                 {
                     if((snake.x[i] == snake.x[0]) && (snake.y[i] == snake.y[0]))
                     {
                         GameOver();                  /*显示失败*/
                         snake.life = 1;
                         break;
                     }
                 }
                 if((snake.x[0] < 55) || (snake.x[0] > 595) || (snake.y[0] < 55) || (snake.y[0] > 455))     /*蛇是否撞到墙壁*/
                 {
     
     
                     GameOver();                                            /*本次游戏结束*/
                     snake.life = 1;                                        /*蛇死*/
                 }
                 if(snake.life == 1)                                        /*以上两种判断以后,如果蛇死就跳出内循环,重新开始*/
                     break;
                 if((snake.x[0] == food.x) && (snake.y[0] == food.y))       /*吃到食物以后*/
                 {
                     setcolor(BLACK);                                       /*把画面上的食物东西去掉*/
                     rectangle(food.x,food.y,food.x+10,food.y-10);
                     snake.x[snake.node] = -20;
                     snake.y[snake.node] = -20;
     
                     /* 新的一节先放在看不见的位置,下次循环就取前一节的位置 */
     
                     snake.node++;                      /*蛇的身体长一节*/
                     food.yes = 1;                      /*画面上需要出现新的食物*/
                     score += 10;
                     PrScore();                         /*输出新得分*/
                 }
                 setcolor(RED);                         /*画出蛇*/
     
     
                 for(i=0;i<snake.node;i++)
                     rectangle(snake.x[i],snake.y[i],snake.x[i]+10,snake.y[i]-10);
                 Sleep(gamespeed);                        /*用延迟控制贪吃蛇速度*/                
                 setcolor(BLACK);                        /*用黑色去除蛇的的最后一节*/
                 rectangle(snake.x[snake.node-1],snake.y[snake.node-1],
                           snake.x[snake.node-1]+10,snake.y[snake.node-1]-10);
             }        /*endwhile(!kbhit)*/
              
             if(snake.life == 1)                        /*如果蛇死就跳出循环*/
                 break;
              
             key=getch();                          /*接收按键*/
             if (key == ESC) break;                  /*按ESC键退出*/
              
             switch(key)
             {                                
                 case UP:
                     if(snake.direction != 4)           /*判断是否往相反的方向移动*/
                         snake.direction = 3;
                     break;
                 case RIGHT:
                     if(snake.direction != 2)
                         snake.direction = 1;
                     break;
                 case LEFT:
                     if(snake.direction != 1)
                         snake.direction = 2;
                     break;
                 case DOWN:
                     if(snake.direction != 3)
                         snake.direction = 4;
                     break;
             }
     
         }/*endwhile(1)*/
    }
     
    /*游戏结束*/
    static void GameOver(void)
    {
         cleardevice();
         PrScore();
         setcolor(RED);
         setfont(56,0,"黑体");
         outtextxy(200,200,"GAME OVER");
         getch();
    }
     
    /*输出成绩*/
    static void PrScore(void)
    {
         char str[10];
     
         setfillstyle(YELLOW);
         bar(50,15,220,35);
         setcolor(BROWN);
         setfont(16,0,"宋体");
         sprintf(str,"score:%d",score);
         outtextxy(55,16,str);
    }
     
    static void Close(void)
    {
         closegraph();
    }

最后一次编辑时间 推荐于2017-09-01 20:05:54
j78903
j78903


j78903:c语言贪吃蛇源代码怎么用?

下面的解答已被1144人点赞

    C语言贪吃蛇源代码必须经过相应的C/C++编译器编译成EXE文件后才能运行。

    由于我们通常使用的操作系统是Windows系统,而在该系统下最长用的C/C++编译器是VC++编译器,目前在大专院校常用的版本还是VC++6.0

   下面就以VC++6.0来说明编译过程:

1.在VC++6.0中通过“File”菜单下的 “Open”子菜单打开贪吃蛇代码

 

2.在VC++6.0中通过“Build”菜单下的 “Compile xxxx.xx”子菜单编译贪吃蛇代码

 

3.在VC++6.0中通过“Build”菜单下的 “Execute xxxx.exe”子菜单运行贪吃蛇程序

 

 

    附:在VC++6环境下可运行的C/C++贪吃蛇源代码(无版权,自己编写,欢迎任意修改拷贝)

/*
C/C++贪吃蛇游戏,zjlj,2015.3.16
*/
#define DEBUG 0 //当程序在调试阶段时 DEBUG为 1
#include<iostream>
#include<windows.h>
#include<time.h>
#include<conio.h>
using namespace std;
void readini(FILE **fphead, int *score, char *argv[]) //创建或打开一个和运行文件对应的ini文件,读取最高纪录
{
 char filename[200],*pfilename;
 int flag=-1,i;
    
    strcpy(filename,argv[0]);
    for(i=0;filename[i]!='\0';i++)
 {
  if ('.'==filename[i])flag=1;
 }
 
 if(1==flag)
 {
 filename[i-1]='i';
    filename[i-2]='n';
 filename[i-3]='i';
 }
 else
 {
  filename[i]='.';
 filename[i+1]='i';
 filename[i+2]='n';
    filename[i+3]='i';
    filename[i+4]='\0';
 }
 for(;filename[i]!='\\'&&i>=0;i--)pfilename=&filename[i];
    if ( (*fphead=fopen(pfilename, "rb+"))==NULL)
 {
        if ( (*fphead=fopen(pfilename, "wb+"))==NULL)
  {
    printf("无法创建或打开\"%s\"文件\n",pfilename);
    system("pause");
       exit(0);
  }
    }
 else
 {
  fread(score,sizeof(int),1,*fphead);
 }
}
void writeini(FILE **fphead, int *score, char *argv[])  //打开一个和运行文件对应的ini文件,写入最高纪录
{
 char filename[200],*pfilename;
 int flag=-1,i;
   
    strcpy(filename,argv[0]);
    for(i=0;filename[i]!='\0';i++)
 {
  if ('.'==filename[i])flag=1;
 }
 
 if(1==flag)
 {
 filename[i-1]='i';
    filename[i-2]='n';
 filename[i-3]='i';
 }
 else
 {
  filename[i]='.';
 filename[i+1]='i';
 filename[i+2]='n';
    filename[i+3]='i';
    filename[i+4]='\0';
 }
 for(;filename[i]!='\\'&&i>=0;i--)pfilename=&filename[i];
    if ( (*fphead=fopen(pfilename, "wb+"))==NULL)
 {
          printf("无法写入\"%s\"文件,磁盘写保护!\n",pfilename);
    system("pause");
       exit(0);
 }
 else
 {
  rewind(*fphead);
  fwrite(score,sizeof(int),1,*fphead);
  fclose(*fphead);
 }
}
void gotoxy(int x,int y)//光标定位,光标定位函数SetConsoleCursorPosition是左上角位置是0,0然后向左向下延伸
{
COORD pos;
pos.X=2*y;
pos.Y=x;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),pos);
}
void color(int a)//颜色函数
{
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),a);
}

void Refresh(int q[][22], int grade, int gamespeed, int length,int score) //  输出贪吃蛇棋盘
{
 int i,j;
 for(i=0;i<22;i++)
 {
  for(j=0;j<22;j++)
  {
   if(q[i][j]==0)//输出棋盘空白
   {
    gotoxy(i,j);
    color(11);
    cout<<"■";
   }
   if(q[i][j]==1||q[i][j]==2)//输出棋盘墙壁
   {  
    gotoxy(i,j);
    color(11);
    cout<<"□";
   }
   if(q[i][j]==3)//输出蛇头
   {  
    gotoxy(i,j);
    color(14);
    cout<<"★";
   }
   if(q[i][j]==4)//输出蛇身
   {  
    gotoxy(i,j);
    color(12);
    cout<<"◆";
   }
     if(q[i][j]==5)//输出果子
   {  
    gotoxy(i,j);
    color(12);
    cout<<"●";
   }
  }
  if(i==0) cout << "\t***********************";
  if(i==1) cout << "\t等级为:" << grade;//显示等级
  if(i==3) cout << "\t自动前进时间";
  if(i==4) cout << "\t间隔为:" << gamespeed << "ms";//显示时间
     if(i==6) cout << "\t历史最高分为:" << score << "分";
  if(i==7) cout << "\t你现在得分为:" << (length+(grade-1)*8)*10 << "分";
  if(i==8) cout << "\t**********************";
     if(i==9) cout << "\t游戏说明:";
     if(i==10) cout << "\t(1)用小键盘方向键控制";
  if(i==11) cout << "\t蛇头运动方向;";
  if(i==12) cout << "\t(2)蛇每吃一个果子蛇身";
  if(i==13) cout << "\t增加一节;";
  if(i==14) cout << "\t(3)蛇咬到自己或碰到墙";
  if(i==15) cout << "\t壁游戏结束。";
  if(i==18) cout << "\t**********************";
     if(i==19) cout << "\tC/C++语言作业:";
     if(i==20) cout << "\tzjlj,2015.03.16 ";
 }
}
 
int main(int argc, char *argv[]){
    int tcsQipan[22][22];     //  贪吃蛇棋盘是一个二维数组(如22*22,包括墙壁)
    int i,j,score,directiontemp;
 FILE  *fpini;//*fpini 信息文件
 readini(&fpini, &score, argv);//读取ini文件的最高纪录
 if (score<0)//最高成绩小于零设置为零,初建文件会是负数
  score=0;
 while(1)
 {
  for(i=1;i<=20;i++)
   for(j=1;j<=20;j++)
    tcsQipan[i][j]=0;    //贪吃蛇棋盘相应坐标标上中间空白部分的标志0
  for(i=0;i<=21;i++)
   tcsQipan[0][i] = tcsQipan[21][i] = 1;      //贪吃蛇棋盘相应坐标标上上下墙壁的标志1
  for(i=1;i<=20;i++)
   tcsQipan[i][0] = tcsQipan[i][21] = 2;      //贪吃蛇棋盘相应坐标标上左右墙壁的标志2
  int tcsZuobiao[2][500];     //蛇的坐标数组
  for(i=0; i<4; i++)
  {
   tcsZuobiao[0][i] = 1;//蛇身和蛇头的x坐标
   tcsZuobiao[1][i] = i + 1;//蛇身和蛇头的y坐标
  }
  int head = 3,tail = 0;//标示蛇头和蛇尾的数组偏移量
  for(i=1;i<=3;i++)
   tcsQipan[1][i]=4;    //蛇身
  tcsQipan[1][4]=3;       //蛇头
  int x1, y1;           // 随机出果子
  srand(time(0));//设置随机种子
  do
  {
   x1=rand()%20+1;
   y1=rand()%20+1;
  }
  while(tcsQipan[x1][y1]!=0);//如果不是在空白处重新出果子
  tcsQipan[x1][y1]=5;//贪吃蛇棋盘相应坐标标上果子的标志5
  color(12);
  cout<<"\n\n\t\t\t\t贪吃蛇游戏即将开始 !"<<endl;//准备开始
  long start,starttemp;
  int grade = 1, length = 4;  //设置初始等级和蛇的初始长度
  int gamespeed = 500;  //设置初始前进时间间隔
  for(i=3;i>=0;i--)
  {
   start=clock();
   while(clock()-start<=1000);
   system("cls");
   if(i>0)
    cout << "\n\n\t\t\t\t进入倒计时:" << i << endl;  //倒计时显示
   else
    Refresh(tcsQipan,grade,gamespeed,length,score);  //初始棋盘显示
  }
  int timeover=1,otherkey=1;//初始化超时时间和按键判断参数
  char direction = 77;  // 设置初始情况下,向右运动
  int x=tcsZuobiao[0][head],y=tcsZuobiao[1][head];//保存蛇头坐标到x,y变量
  while(1)//运行一局游戏
  {
   start = clock();
   while((timeover=((starttemp=clock())-start<=gamespeed))&&!kbhit());//如果有键按下或时间超过自动前进时间间隔则终止循环
   if(direction==72||direction==80||direction==75 ||direction==77)
   directiontemp=direction;//保留上一次方向按键
            //starttemp=gamespeed+start-starttemp;//保留停留时间
   if(timeover)
   {
    #if (DEBUG==1)
    direction = getch();//调试代码
             #else
    if((direction =getch())==-32)
     direction = getch();
       #endif
   }
             #if (DEBUG==1)//调试代码
       start=clock();
    while(clock()-start<=2000);
    gotoxy(24,4);
    cout << "\t按键ASCII代码"<<(int)direction<<"    "<<endl;
             #endif
    if(!(direction==72||direction==80||direction==75 ||direction==77))
    {   
     otherkey=0;//  按键非方向键,otherkey设置为0
    }
    else
    {
     otherkey=1;//  按键为方向键,otherkey设置为1
    }
             if(direction==72 && directiontemp==80)//忽略反方向按键
    {
        direction=32;
     otherkey=0;
                 //start = clock();
        //while(clock()-start<=starttemp);
    }
    else if(direction==80 && directiontemp==72)
   {
        direction=32;//设置按键为非方向键
      otherkey=0;//  按键为非方向键,otherkey设置为0
                // start = clock();
       //while(clock()-start<=starttemp);//补偿等待时间
    }
    else if(direction==75 && directiontemp==77)
    {
        direction=32;
     otherkey=0;
                 //start = clock();
        //while(clock()-start<=starttemp);
    }
    else if(direction==77 && directiontemp==75)
    {
        direction=32;
     otherkey=0;
                 //start = clock();
        //while(clock()-start<=starttemp);
    }
    
    
    switch(direction)//判断方向键
    {
     case 72: x= tcsZuobiao[0][head]-1; y= tcsZuobiao[1][head];break;      // 向上
     case 80: x= tcsZuobiao[0][head]+1; y= tcsZuobiao[1][head];break;      // 向下
     case 75: x= tcsZuobiao[0][head]; y= tcsZuobiao[1][head]-1;break;      // 向左
     case 77: x= tcsZuobiao[0][head]; y= tcsZuobiao[1][head]+1;break;      // 向右
     default: break;
    }
   
 
    if(x==0 || x==21 ||y==0 || y==21)      // 蛇头碰到墙壁,结束本局游戏
    {  
     gotoxy(22,12);
     cout << "\t游戏已结束!" << endl;
     if(score>=(length+(grade-1)*8)*10)//判断是否破记录
     {
      gotoxy(10,7);
      color(12);
      cout << "闯关失败 加油耶!" << endl;
      fclose(fpini);//关闭ini文件
     }
     else
     {
      gotoxy(10,7);
      color(12);
      cout << "恭喜您打破记录" << endl;
      score=(length+(grade-1)*8)*10;
      writeini(&fpini, &score, argv);//写入ini文件的最高纪录
     }
     gotoxy(23,12);
        cout << "按回车键重新开始,按ESC退出游戏" << endl;//显示的提示
     break;//退出该局游戏
    }
    if(tcsQipan[x][y]!=0&&!(x==x1&&y==y1)&&tcsQipan[x][y]!=3) //   蛇头碰到蛇身,结束本局游戏
    {
     gotoxy(22,12);
     cout << "\t游戏已结束!" << endl;
     if(score>=(length+(grade-1)*8)*10)//判断是否破记录
     {
      gotoxy(10,7);
      color(12);
      cout << "闯关失败 加油耶!" << endl;
      fclose(fpini);//关闭ini文件
     }
     else
     {
      gotoxy(10,7);
      color(12);
      cout << "恭喜您打破记录" << endl;
      score=(length+(grade-1)*8)*10;
      writeini(&fpini, &score, argv);//写入ini文件的最高纪录
     }
     gotoxy(23,12);
     cout << "按回车键重新开始,按ESC退出游戏" << endl;//显示的提示
     break;//退出该局游戏
    }
    /*
    游戏运行时的核心算法开始
    */
    if(x==x1 && y==y1) //  吃果子,长度加1
    {   
     length ++;
     if(length>=8)//长度大于等于8重新计算长度,等级加1
     {
      length -= 8;//重新计算长度
      grade ++;//等级加1
      if(gamespeed>50)//控制最快速度为50
       gamespeed = 550 - grade * 50; // 改变自动前进时间间隔
     }
     tcsQipan[x][y]= 3;//贪吃蛇棋盘相应坐标现在蛇头标志改为蛇头标志3
     tcsQipan[tcsZuobiao[0][head]][tcsZuobiao[1][head]] = 4;//贪吃蛇棋盘相应坐标原来蛇头标志改为蛇身标志4
     head = (head+1)%400;//防止数组越界
     tcsZuobiao[0][head] = x;//蛇头的x坐标
     tcsZuobiao[1][head] = y;//蛇头的y坐标
     do//随机出果子
     {
      x1=rand()%20+1;
      y1=rand()%20+1;
     }
     while(tcsQipan[x1][y1]!=0);//如果不是在空白处重新出果子
     tcsQipan[x1][y1]=5;//贪吃蛇棋盘相应坐标标上果子的标志5
     gotoxy(22,12);
     cout << "\t游戏进行中!" << endl;
     Refresh(tcsQipan,grade,gamespeed,length,score);
    }
    else  //  不吃果子
    {  
     if(otherkey)
     {
      tcsQipan [tcsZuobiao[0][tail]][tcsZuobiao[1][tail]]=0;
      tail=(tail+1)%400;//防止数组越界
      tcsQipan [tcsZuobiao[0][head]][tcsZuobiao[1][head]]=4;
      head=(head+1)%400;//防止数组越界
      tcsZuobiao[0][head]=x;//蛇头的x坐标
      tcsZuobiao[1][head]=y;//蛇头的y坐标
      tcsQipan[tcsZuobiao[0][head]][tcsZuobiao[1][head]]=3;
      gotoxy(22,12);
      cout << "\t游戏进行中!" << endl;
      Refresh(tcsQipan,grade,gamespeed,length,score);
     }
     else
     {
      gotoxy(22,12);
      cout << "\t游戏暂停中!" << endl;
     }
    }
    /*
    游戏运行时的核心算法结束
    */
       }
    while(1)
    {
     while(!kbhit());
     if((direction =getch())==13)//按回车键开始下一局
      break;
     if(direction ==27)//按ESC退出游戏
      exit(0);
    }
       system("cls");//清除屏幕重新开始
 }
 return 0;
}

最后一次编辑时间 推荐于2017-09-10 07:05:52