贪吃蛇编程

㈠ 求用c语言编写的贪吃蛇程序

#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();
}


㈡ 求贪吃蛇的C++程序代码

#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=32000;
struct Food /*食物的结构体*/
{
int x; /*食物的横坐标*/
int y; /*食物的纵坐标*/
int yes; /*食物是否出现的变量*/
}food;
struct Snack /*蛇的结构体*/
{
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 PrScore(void); /*分数输出函数*/

DELAY(char ch)/*调节游戏速度*/
{
if(ch=='3')
{
delay(gamespeed); /*delay是延迟函数*/
delay(gamespeed);
}
else if(ch=='2')
{
delay(gamespeed);
}
}

Menu()/*游戏开始菜单*/
{
char ch;
printf("Please choose the gamespeed:\n");
printf("1-Fast 2-Normal 3-Slow\n");
printf("\nPlease Press The numbers..\n");
do
{ch=getch();}
while(ch!='1'&&ch!='2'&&ch!='3');
clrscr();
return(ch);
}

/*主函数*/
void main(void)
{
int ch;
ch=Menu();
Init();
DrawK();
GamePlay(ch);
Close();
}

void Init(void)
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"c:\\tc");
cleardevice();
}

void DrawK(void)
{
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(char ch)
{
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) /*可以重复游戏*/
{
while(!kbhit()) /*在没有按键的情况下蛇自己移动*/
{
if(food.yes==1) /*需要食物*/
{
food.x=rand()%400+60;
food.y=rand()%350+60; /*使用rand函数随机产生食物坐标*/
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]; /*贪吃蛇的身体移动算法*/
}

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);
DELAY(ch);
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);

}
if(snake.life==1)
break;
key=bioskey(0); /*接受按键*/
if(key==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;
}
}

void GameOver(void)
{
cleardevice();
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,"scord:%d",score);
outtextxy(55,20,str);
}
void Close(void)
{
getch();
closegraph();
}

㈢ 贪吃蛇编程

这里有我以前敲过的贪吃蛇，不介意可以参考一下，（ps:需要建一了application而不是console application）

#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include <time.h>

#define speed 200
#define left 100
#define top 50
#define right 500
#define bottom 350

struct snake
{
POINT pos;
snake *front,*next;
};

LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);
bool InitWindow(HINSTANCE,int);
void items(HDC,int,int);
void MoveSnake(int);
void remove();
void destroy();
void inf(int,int,int,int);
void inf(const char*,int,int,int,int);
void inf(const char*,int,int,int);
bool is_fail();
void eat();
void wall();
void show_fruit();

UINT ShowMode;
PAINTSTRUCT ps;
bool onoff;
HFONT hf;
char judge[20];
int dir;
HDC hdc;
HWND hwnd;
HBRUSH BlackBrush,MainBrush,NULLBrush;
HPEN MainPen,BlackPen;
snake *head,*tail,*temp;
POINT fruit;

int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow
)
{
onoff=1;
int i;
dir=-2;
tail=NULL;
InitWindow(hInstance,nCmdShow);
for(i=0;i<5;i++)
{
if(!tail)
{
head=new snake;
tail=head;
head->pos.x=300+i*10;
head->pos.y=200;
items(hdc,head->pos.x,head->pos.y);
}
else
{
tail->next=new snake;
tail->next->front=tail;
tail=tail->next;
tail->pos.x=300+i*10;
tail->pos.y=200;
tail->next=NULL;
items(hdc,tail->pos.x,tail->pos.y);
}
}
hf=CreateFont(20,0,0,0,400,0,0,0,GB2312_CHARSET,
OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,DEFAULT_PITCH|FF_DONTCARE,"华文行楷");
SelectObject(hdc,hf);
SetBkColor(hdc,RGB(124,146,131));
SelectObject(hdc,MainBrush);
wall();
show_fruit();
inf("得分:",260,0,0);
MSG msg;
while(GetMessage(&msg,NULL,0,0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
destroy();
return 0;
}

LRESULT CALLBACK WndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
static int seed=15;
switch(msg)
{
case WM_TIMER:
MoveSnake(dir);
if(!is_fail())
{
KillTimer(hwnd,1);
MessageBox(hwnd,"you are lost","caption",0);
}
eat();
break;
case WM_PAINT:
hdc=BeginPaint(hwnd,&ps);
wall();
EndPaint(hwnd,&ps);
hdc=GetDC(hwnd);
case WM_KEYDOWN:
switch(wParam)
{
case VK_UP:dir=(dir!=1?-1:dir);break;
case VK_DOWN:dir=(dir!=-1?1:dir);break;
case VK_RIGHT:dir=(dir!=-2?2:dir);break;
case VK_LEFT:dir=(dir!=2?-2:dir);break;
}
break;
case WM_CLOSE:
if(MessageBox(hwnd,"确定退出？","caption",MB_YESNO)==IDYES)
DestroyWindow(hwnd);
break;
case WM_DESTROY:
ReleaseDC(hwnd,hdc);
KillTimer(hwnd,1);
PostQuitMessage(0);
break;
default:return DefWindowProc(hwnd,msg,wParam,lParam);
}

return 1;
}

bool InitWindow(HINSTANCE hInstance,int nCmdShow)
{
WNDCLASS wc;
wc.style=CS_HREDRAW | CS_VREDRAW;
wc.lpszClassName="test";
wc.lpszMenuName=NULL;
wc.cbClsExtra=0;
wc.cbWndExtra=0;
wc.hbrBackground=CreateSolidBrush(RGB(124,146,131));
wc.hIcon=NULL;
wc.hCursor=LoadCursor(NULL,IDC_ARROW);
wc.hInstance=hInstance;
wc.lpfnWndProc=WndProc;

MainBrush=CreateSolidBrush(RGB(124,146,131));
BlackBrush=(HBRUSH)GetStockObject(BLACK_BRUSH);
NULLBrush=(HBRUSH)GetStockObject(NULL_BRUSH);
MainPen=CreatePen(PS_SOLID,1,RGB(124,146,131));
BlackPen=CreatePen(PS_SOLID,1,RGB(0,0,0));

if(!RegisterClass(&wc)) return false;
hwnd=CreateWindow("test","贪吃蛇",WS_SYSMENU,400,150,616,400,NULL,NULL,hInstance,NULL);
hdc=BeginPaint(hwnd,&ps);
if(!hwnd) return false;

ShowWindow(hwnd,SW_SHOWNORMAL);
UpdateWindow(hwnd);
SetTimer(hwnd,1,speed,NULL);
return true;
}

void items(HDC hdc,int x,int y)
{
SelectObject(hdc,BlackPen);
SelectObject(hdc,NULLBrush);
Rectangle(hdc,x,y,x+10,y+10);
SelectObject(hdc,BlackBrush);
Rectangle(hdc,x+2,y+2,x+8,y+8);
// DeleteObject(BlackPen);
// DeleteObject(BlackBrush);
}

void MoveSnake(int dir)
{
static int i=0;
remove();
tail=tail->front;
delete tail->next;
tail->next=NULL;
temp=new snake;
temp->next=head;
head->front=temp;
temp->pos.x=head->pos.x+(dir/2)*10;
temp->pos.y=head->pos.y+(dir%2)*10;
head=temp;
i++;
items(hdc,head->pos.x,head->pos.y);
}

void remove()
{
SelectObject(hdc,MainBrush);
SelectObject(hdc,MainPen);
Rectangle(hdc,tail->pos.x,tail->pos.y,tail->pos.x+10,tail->pos.y+10);
// DeleteObject(MainBrush);
// DeleteObject(MainPen);
}

void destroy()
{
while(head->next)
{
head=head->next;
delete head->front;
}
delete tail;
}

void inf(int x,int y,int px,int py)
{
inf("",x,y,px,py);
}
void inf(const char*str,int x,int y,int scores)
{
sprintf(judge,"%s%d",str,scores);
TextOut(hdc,x,y,judge,strlen(judge));
}
void inf(const char*str,int x,int y,int px,int py)
{
sprintf(judge,"%s(%d,%d) ",str,px,py);
TextOut(hdc,x,y,judge,strlen(judge));
}

bool is_fail()
{
temp=head;
int px=head->pos.x,py=head->pos.y;
if(px<left||px>=right||py<top||py>=bottom)
return 0;
while(temp->next)
{
temp=temp->next;
if(px==temp->pos.x&&py==temp->pos.y)
return 0;
}
return 1;

}

void show_fruit()
{
srand((UINT)time(NULL));
fruit.x=10*((rand()%(right-left-10))/10)+left;
fruit.y=10*((rand()%(bottom-top-10))/10)+top;
items(hdc,fruit.x,fruit.y);
}

void eat()
{
inf("食物:",0,25,fruit.x,fruit.y);
inf("蛇头:",0,0,head->pos.x,head->pos.y);
static int scores=0;
if(head->pos.x==fruit.x&&head->pos.y==fruit.y)
{
scores++;
inf("得分:",260,0,scores);
KillTimer(hwnd,1);
temp=new snake;
temp->next=head;
head->front=temp;
temp->pos.x=head->pos.x+(dir/2)*10;
temp->pos.y=head->pos.y+(dir%2)*10;
head=temp;
items(hdc,head->pos.x,head->pos.y);
SetTimer(hwnd,1,speed,NULL);
show_fruit();
}
}

void wall()
{
SelectObject(hdc,MainBrush);
Rectangle(hdc,left-1,top-1,right+1,bottom+1);
// DeleteObject(MainBrush);
}

㈣ C语言的贪吃蛇源代码

#include <bits/stdc++.h>

#include <windows.h>
#include <conio.h>
using namespace std;
void gotoxy(int x,int y) {COORD pos={x,y}; SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),pos);}//光标定位
class Food {//食物类
private: int m_x; int m_y;
public:
void randfood() {//随机产生一个食物
srand((int)time(NULL));//利用时间添加随机数种子，需要ctime头文件
L1:{m_x=rand()%(85)+2;//2~86
m_y=rand()%(25)+2;//2~26
if(m_x%2) goto L1;//如果食物的x坐标不是偶数则重新确定食物的坐标
gotoxy(m_x,m_y);//在确认好的位置输出食物
cout << "★";}}
int getFoodm_x() {return m_x;}//返回食物的x坐标
int getFoodm_y() {return m_y;}};//返回食物的y坐标
class Snake {
private:
struct Snakecoor {int x; int y;};//定义一个蛇的坐标机构
vector<Snakecoor> snakecoor;//将坐标存入vector容器中
//判断并改变前进方向的函数
void degdir(Snakecoor&nexthead) {//定义新的蛇头变量
static char key='d';//静态变量防止改变移动方向后重新改回来
if(_kbhit()) {
char temp=_getch();//定义一个临时变量储存键盘输入的值
switch(temp) {//如果临时变量的值为wasd中的一个，则赋值给key
default: break;//default是缺省情况，只有任何条件都不匹配的情况下才会执行 必须写在前面！不然蛇无法转向
case'w': case'a': case's': case'd':
//如果temp的方向和key的方向不相反则赋值 因为两次移动方向不能相反 将蛇设置为初始向右走
if(key=='w' && temp!='s' || key=='s' && temp!='w' || key=='a' && temp!='d' || key=='d' && temp!='a') key=temp;}}
switch (key) {//根据key的值来确定蛇的移动方向
case'd': nexthead.x=snakecoor.front().x+2; nexthead.y=snakecoor.front().y; break;
//新的蛇头的头部等于容器内第一个数据(旧蛇头)x坐标+2 因为蛇头占两个坐标，移动一次加2
case'a': nexthead.x=snakecoor.front().x-2; nexthead.y=snakecoor.front().y; break;
case'w': nexthead.x=snakecoor.front().x; nexthead.y=snakecoor.front().y-1; break;
//因为控制台的x长度是y的一半，所以用两个x做蛇头，需要的坐标是二倍
case's': nexthead.x=snakecoor.front().x; nexthead.y=snakecoor.front().y+1;}}
//游戏结束时设计一个界面输出“游戏结束”以及分数
void finmatt(const int score) {
system("cls"); gotoxy(40, 14);//清屏然后输出
cout << "游戏结束"; gotoxy(40, 16);
cout << "得分：" << score; gotoxy(0, 26);
exit(0);}//exit为C++的退出函数 exit(0)表示程序正常退出，非0表示非正常退出
void finishgame(const int score) {//游戏结束
if(snakecoor[0].x>=88 || snakecoor[0].x<0 || snakecoor[0].y>=28 || snakecoor[0].y<0) finmatt(score);//撞墙
for(int i=1;i<snakecoor.size();i++) if(snakecoor[0].x==snakecoor[i].x && snakecoor[0].y==snakecoor[i].y) finmatt(score);}//撞到自身
public://构造初始化蛇的位置
Snake() { Snakecoor temp;//临时结构变量用于创建蛇
for(int i=5;i>=0;i--) {//反向创建初始蛇身，初始蛇头朝右
temp.x=16+(i<<1); temp.y=8;//偶数 在蛇头左移生成蛇身
snakecoor.push_back(temp);}}//在蛇尾尾插入临时变量
void move(Food&food, int& score) {//蛇运动的函数
Snakecoor nexthead;//新蛇头变量
degdir(nexthead);//判断和改变蛇前进的方向
snakecoor.insert(snakecoor.begin(), nexthead);//将蛇头插入容器的头部
gotoxy(0, 0); cout << "得分：" << score;//每次移动都在左上角刷新得分
gotoxy(0, 2); cout << "蛇的长度为：" << snakecoor.size();//长度用来测试
finishgame(score);//判断游戏结束，输出分数
//吃到食物蛇的变化
if(snakecoor[0].x==food.getFoodm_x() && snakecoor[0].y==food.getFoodm_y()) {//蛇头与食物重合
gotoxy(snakecoor[0].x, snakecoor[0].y); cout << "●";//吃到食物时这次蛇没有移动，所以蛇会卡顿一下
gotoxy(snakecoor[1].x, snakecoor[1].y); cout << "■";//重新输出一下蛇头和第一节蛇身让蛇不卡顿
score++; food.randfood(); return;}//吃到食物得分+1,如果蛇头坐标和食物坐标重合则重新产生一个食物并直接结束本次移动
for(int i=0;i<snakecoor.size();i++) {//遍历容器，判断食物与蛇身是否重合并输出整条蛇
gotoxy(snakecoor[i].x, snakecoor[i].y);
if (!i) cout << "●"; else cout << "■";//头部输出圆形否则输出方块
if (snakecoor[i].x==food.getFoodm_x() && snakecoor[i].y==food.getFoodm_y())food.randfood();}//如果食物刷新到了蛇身上，则重新产生一个
gotoxy(snakecoor.back().x,snakecoor.back().y);cout << " ";snakecoor.pop_back();}};
//数据与画面是分开，的在容器尾部的地方输出空格 清除画面上的蛇尾，删除容器中最后一个数据 清除数据上的蛇尾
void HideCursor() {CONSOLE_CURSOR_INFO cursor_info={1,0};SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),&cursor_info);}//隐藏光标
int main() {system("mode con cols=88 lines=28"); system("title 贪吃蛇"); HideCursor();//光标隐藏，设置控制台窗口大小、标题
int score=0; Food food; food.randfood(); Snake snake;//得分变量，食物对象，开局随机产生一个食物，蛇对象
while(true) {snake.move(food, score);Sleep(150);}return 0;}//蛇移动,游戏速度

㈤ c#编程贪吃蛇

usingSystem;usingSystem.Collections.Generic;usingSystem.ComponentModel;usingSystem.Data;usingSystem.Drawing;usingSystem.Linq;usingSystem.Text;usingSystem.Windows.Forms;

namespaceSnakeGame
{
publicpartialclassfrmSnake:Form
{
publicPointFoodLct=newPoint();//缓存食物的坐标
publicintsnakeLen=6;
publicconstintSnakeMaxLength=500;
publicPoint[]snakeArr=newPoint[SnakeMaxLength];
publicintsnakeDrt=2;
publicboolpanDuan=true;
publicfrmSnake()
{
InitializeComponent();
inttemp=0;
for(inti=snakeLen-1;i>=0;i--)
{
snakeArr[i].X=temp;snakeArr[i].Y=0;
temp+=15;
}
}

/*
前言
说到贪吃蛇，大家可能小时候都玩过，小菜最近在整理Winfrom的学习系列，那我觉得有兴趣才会有学习，就从这个小游戏讲起吧。

其实我刚开始学习编程的时候，感觉写个贪吃蛇的程序会很难，因为涉及到画图什么的，其实现在来看，实现很简单。

实现贪吃蛇首先有几个元素：
蛇
食物

然后有几个行为：
吃食物和吃不到食物
撞墙和撞自己
说到这有点oo的意思啊，这篇就不啰嗦，只是简单实现，下篇会优化下。

其实整个贪吃蛇的难点就在于画图，可能用其他语言实现有点复杂，但是强大的.net提供了GDI+绘图机制，实现起来就很方便了，其次就是细节的处理，比如坐标的定位，蛇的行走路线等。

我们简单一点来看，食物可以看成一个小方格，蛇是有N个小方格组成，那我们就可以用GDI+这样实现：


///<summary>
///画一个小方块
///</summary>
publicvoidDrawShape(intx,inty)
{
Graphicsg=this.CreateGraphics();
Penpen=newPen(Color.Blue,2);
g.DrawRectangle(pen,x,y,15,15);
g.FillRectangle(Brushes.Green,x,y,15,15);
}

///<summary>
///画一个食物
///</summary>
publicvoidDrawFood(intx,inty)
{
Graphicsg=this.CreateGraphics();
Penpen=newPen(Color.Red,2);
SolidBrushbrush=newSolidBrush(Color.Green);
g.DrawRectangle(pen,x,y,15,15);
g.FillRectangle(brush,x,y,15,15);
}

Graphics这个类我就不多说，大家可以看看MSDN上介绍的用法，上面是画蛇的最小单元-方格，和一个食物方格，蛇的方格大小是15*15，边框颜色是Blue，填充色是Green；食物方格的大小是15*15，边框颜色是Red，填充色是Green。

画好了基本元素，那下面就是用基本元素来表现蛇了，可以用Point数组来存储蛇的坐标，也就是每个方格的坐标，我们先看下代码：
///<summary>
///设置Point数组坐标
///</summary>
publicvoidForward(intdrt)
{
Pointtemp=snakeArr[0];
for(inti=snakeLen-1;i>0;i--)
{
snakeArr[i].X=snakeArr[i-1].X;
snakeArr[i].Y=snakeArr[i-1].Y;
}

switch(drt)
{
case1:
snakeArr[0].X=temp.X;
snakeArr[0].Y=temp.Y-15;
break;//上
case2:
snakeArr[0].X=temp.X+15;
snakeArr[0].Y=temp.Y;
break;//右
case3:
snakeArr[0].X=temp.X;
snakeArr[0].Y=temp.Y+15;
break;//下
case4:
snakeArr[0].X=temp.X-15;
snakeArr[0].Y=temp.Y;
break;//左
}
}
drt参数是键盘上上下左右键对应的数字，snakeLen是数组的长度也就是方格的个数，上面那个for循环主要的作用是把前一个数组的坐标赋值给下一个，就像是毛毛虫爬行一样，后一节会按照前一节的路线来爬，下面那个switch的作用是，设置蛇头的行进路线。

再下面就是判断蛇是否吃到食物、是否撞到墙和撞到自己，因为蛇和食物都是用坐标存储的，所以只要判断蛇头坐标是否等于食物坐标就可以了：

///<summary>
///判断是否吃到食物
///</summary>
publicboolEatedFoot(PointFoodLct)
{
if(snakeArr[0].X==FoodLct.X&&snakeArr[0].Y==FoodLct.Y)
{
if(snakeLen<SnakeMaxLength)
{
snakeLen++;
snakeArr[snakeLen].X=snakeArr[snakeLen-1].X;
snakeArr[snakeLen].Y=snakeArr[snakeLen-1].Y;
}
returntrue;
}
else
returnfalse;
}

///<summary>
///判断是否撞到自己
///</summary>
()
{
returnthis.CheckInSnakeBody(this.snakeArr[0].X,this.snakeArr[0].Y,1);
}

///<summary>
///检查输入的坐标是否在蛇的身上
///</summary>
publicboolCheckInSnakeBody(intx,inty,intsnkHead)
{
for(inti=snkHead;i<snakeLen;i++)
{
if(x==this.snakeArr[i].X&&y==this.snakeArr[i].Y)
{
returntrue;
}
}returnfalse;
}

///<summary>
///判断是否撞墙
///</summary>
///<returns></returns>
publicboolCheckSnakeBodyInFrm()
{
if(this.snakeArr[0].X>=594||this.snakeArr[0].Y>=399-32||this.snakeArr[0].X<0||this.snakeArr[0].Y<0)
returntrue;
else
returnfalse;
}*/

/*实现上面的几个步骤，简单版的贪吃蛇基本上就完成了，再加上一个timer控件，这样蛇就会“动”起来了，就这么简单。
完整代码：*/

///<summary>
///画一个小方块
///</summary>
publicvoidDrawShape(intx,inty)
{
Graphicsg=this.CreateGraphics();
Penpen=newPen(Color.Blue,2);
g.DrawRectangle(pen,x,y,15,15);
g.FillRectangle(Brushes.Green,x,y,15,15);
}

///<summary>
///画一个食物
///</summary>
publicvoidDrawFood(intx,inty)
{
Graphicsg=this.CreateGraphics();
Penpen=newPen(Color.Red,2);
SolidBrushbrush=newSolidBrush(Color.Green);
g.DrawRectangle(pen,x,y,15,15);
g.FillRectangle(brush,x,y,15,15);
}

///<summary>
///设置Point数组坐标
///</summary>
publicvoidForward(intdrt)
{
Pointtemp=snakeArr[0];
for(inti=snakeLen-1;i>0;i--)
{
snakeArr[i].X=snakeArr[i-1].X;
snakeArr[i].Y=snakeArr[i-1].Y;
}
switch(drt)
{
case1:snakeArr[0].X=temp.X;snakeArr[0].Y=temp.Y-15;break;//上
case2:snakeArr[0].X=temp.X+15;snakeArr[0].Y=temp.Y;break;//右
case3:snakeArr[0].X=temp.X;snakeArr[0].Y=temp.Y+15;break;//下
case4:snakeArr[0].X=temp.X-15;snakeArr[0].Y=temp.Y;break;//左
}
}

///<summary>
///时间事件///</summary>
privatevoidtimer1_Tick(objectsender,EventArgse)
{
Graphicsg=this.CreateGraphics();
g.Clear(Color.DarkKhaki);//清除整个画面

Forward(snakeDrt);
for(inti=0;i<snakeLen;i++)
{
DrawShape(snakeArr[i].X,snakeArr[i].Y);
}
if(panDuan)
{
ShowFood();//DrawFood(FoodLct.X,FoodLct.Y);
panDuan=false;
}
if(EatedFoot(FoodLct))
{
ShowFood();
DrawFood(FoodLct.X,FoodLct.Y);
}
else
{
DrawFood(FoodLct.X,FoodLct.Y);
}
if(CheckSnakeHeadInSnakeBody()||CheckSnakeBodyInFrm())
{
this.timer1.Enabled=false;
MessageBox.Show("游戏结束！");
}
}

///<summary>
///按下方向键
///</summary>
privatevoidfrmSnake_KeyDown(objectsender,KeyEventArgse)
{
if(e.KeyCode==Keys.Up)snakeDrt=1;
elseif(e.KeyCode==Keys.Down)
snakeDrt=3;
elseif(e.KeyCode==Keys.Right)
snakeDrt=2;
elseif(e.KeyCode==Keys.Left)
snakeDrt=4;
}

///<summary>
///判断是否撞到自己
///</summary>
()
{
returnthis.CheckInSnakeBody(this.snakeArr[0].X,this.snakeArr[0].Y,1);
}

///<summary>
///检查输入的坐标是否在蛇的身上
///</summary>
publicboolCheckInSnakeBody(intx,inty,intsnkHead)
{
for(inti=snkHead;i<snakeLen;i++)
{
if(x==this.snakeArr[i].X&&y==this.snakeArr[i].Y)
{
returntrue;
}
}
returnfalse;
}

///<summary>
///判断是否撞墙
///</summary>
///<returns></returns>
publicboolCheckSnakeBodyInFrm()
{
if(this.snakeArr[0].X>=594||this.snakeArr[0].Y>=399-32||this.snakeArr[0].X<0||this.snakeArr[0].Y<0)
returntrue;
else
returnfalse;
}

///<summary>
///随机显示食物
///</summary>
publicvoidShowFood()
{
Randomrmd=newRandom();
intx,y;x=rmd.Next(0,this.Width/15)*15;
y=rmd.Next(0,this.Height/15)*15;
//while(this.CheckInSnakeBody(x,y,1))
//{
//x=rmd.Next(0,32)*15;
//y=32+rmd.Next(0,30)*15;
//}
FoodLct.X=x;
FoodLct.Y=y;
}

///<summary>
///判断是否吃到食物
///</summary>
publicboolEatedFoot(PointFoodLct)
{
if(snakeArr[0].X==FoodLct.X&&snakeArr[0].Y==FoodLct.Y)
{
if(snakeLen<SnakeMaxLength)
{
snakeLen++;
snakeArr[snakeLen].X=snakeArr[snakeLen-1].X;
snakeArr[snakeLen].Y=snakeArr[snakeLen-1].Y;
}returntrue;
}
else
returnfalse;
}
}
}

㈥ c语言 贪吃蛇 程序

基本思路：

蛇每吃一个食物蛇身子就增加一格，用UP, DOWN, LEFT, RIGHT控制蛇头的运动，而蛇身子跟着蛇头走，每后一格蛇身子下一步走到上一格蛇身子的位置，以此类推。

#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;

}

(6)贪吃蛇编程扩展阅读：

实现逻辑

1，可以设置光标，就能实现制定位置打印制定符号。

2，涉及一个结构体，包含两个元素坐标元素和一个结构体指针。

3，结构体串联形成链表，遍历获取成员坐标，打印符号得到蛇身。

4，不断的加头，去尾，重新遍历坐标，再打印形成蛇的移动。

5，食物产生的位置判定，不能越界，也不能与蛇身体重合。

6，蛇的转向判定，一条规则，不允许倒退。

7，转向的实现，跟行进方向决定新的关节坐标（当前头的上下左右）

8，死亡检测，是否头节点坐标是否与墙壁重合，是否与身体其他关节重合。

9，加速减速，设置刷新休眠时间实现。

㈦ 贪吃蛇plc编程思路

贪吃蛇变成了自助的，这你应该找找贪吃蛇的业绩上关于编程方面的。

㈧ 用C语言编写贪吃蛇游戏的程序

回答：Mr.emily
大师
6月3日
16:45
#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;
}snake;
void
Init();
void
Close();
void
DrawK();
void
GamePlay();
void
GameOver();
void
PrScore();
void
main()
{
Init();
DrawK();
GamePlay();
Close();
}
void
Init()
{int
gd=DETECT,gm;
initgraph(&gd,&gm,"F:\\tuoboc2");/*此处为turboc的路径，读者可以根据自己的电脑而改*/
cleardevice();
}
void
DrawK()
{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()
{randomize();
food.yes=1;
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)
{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];
}
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);
}
if(snake.life==1)
break;
key=bioskey(0);
if(key==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;
}
}
void
GameOver()
{
cleardevice();
PrScore();
setcolor(RED);
settextstyle(3,0,4);
outtextxy(100,100,"Mengmeng,i
love
you!");
getch();
}
void
PrScore()
{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()
{
getch();
closegraph();
}
Mr.emily

㈨ 简单贪吃蛇C语言程序

#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/*蛇的最大长度*/
#define M 3 /*食物数量*/
#define F 2 /*毒花数量*/
int i,j,key;
int k=0;
int a=0;
int map[20][20];/*障碍地图*/
int score=200;/*得分*/
int gamespeed;/*游戏速度自己调整*/
int level=1; /*游戏级别*/
struct Food
{
int x;/*食物的横坐标*/
int y;/*食物的纵坐标*/
int yes;/*判断是否要出现食物的变量*/
}food[M];/*食物的结构体*/
struct Flower
{
int x;
int y;
int yes;
}flower[F]; /*毒花的结构体*/
struct Lucky
{
int x;
int y;
int yes;
}lucky;/*救命稻草结构体*/
struct Snake
{
int x[N];
int y[N];
int node;/*蛇的节数*/
int direction;/*蛇移动方向*/
int life;/* 蛇的生命,0死亡*/
}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），右下角坐标为（595，460）的围墙*/
void DrawK(void)
{
setcolor(RED);
rectangle(50,40,595,460);

}
/*玩游戏具体过程*/
void GamePlay(void)
{
int ii,jj;
randomize();

for(i=0;i<M;i++)/*随机数发生器*/
food[i].yes=1;/*1表示需要出现新食物,0表示已经存在食物*/
for(i=0;i<F;i++)
flower[i].yes=1;

snake.life=25;
snake.direction=1;/*方向往右*/
snake.x[0]=110;snake.y[0]=60;
snake.x[1]=100;snake.y[1]=60;/*蛇头*/
snake.node=2;/*节数*/
PrScore();/*输出得分*/

while(1)/*可以重复玩游戏,压ESC键结束*/
{

while(!kbhit())/*在没有按键的情况下,蛇自己移动身体*/
{
/*画地图*/
setcolor(RED);
for(i=0;i<20;i++)
for(j=0;j<20;j++)
{
if(map[i][j])
rectangle(200+j*10-5,100+i*10-5,210+j*10-5,110+i*10-5);
}

for(i=0;i<M;i++)
{
if(food[i].yes==1)/*需要出现新食物*/
{
food[i].x=rand()%400+60;
food[i].y=rand()%350+60;
while(food[i].x%10!=0)/*食物随机出现后必须让食物能够在整格内,这样才可以让蛇吃到*/
food[i].x++;
while(food[i].y%10!=0)
food[i].y++;

for(ii=0;ii<20;ii++)
for(jj=0;jj<20;jj++)
if(map[ii][jj]){
while(food[i].x==200+jj*10&&food[i].y==100+ii*10)
food[i].x+=10; } /*不让食物在内墙上出现*/

food[i].yes=0;/*画面上有食物了*/
}
if(food[i].yes==0)/*画面上有食物了就要显示*/
{
setcolor(GREEN);
circle(food[i].x,food[i].y,4);

}
}
for(i=0;i<F;i++)
{
if(flower[i].yes==1)
{
flower[i].x=rand()%400+60;
flower[i].y=rand()%350+60;
while(flower[i].x%10!=0)
flower[i].x++;
while(flower[i].y%10!=0)
flower[i].y++;

for(ii=0;ii<20;ii++)
for(jj=0;jj<20;jj++)
if(map[ii][jj])
{
if(flower[i].x==200+jj*10&&flower[i].y==100+ii*10)
flower[i].x+=10; /*不让毒花在内墙上出现*/
}

for(ii=0;ii<M;ii++)
{
while(flower[i].x==food[ii].x&&flower[i].y==food[ii].y)
flower[i].x+=10;/*不让毒花与食物重合*/
}

flower[i].yes=0; /*画面上有毒花了*/

}

if(flower[i].yes==0) /*画面上有毒花了就要显示*/
{
setcolor(WHITE); /*毒花为白色*/
circle(flower[i].x,flower[i].y,4);
}

}
if(level>=3&&a==0)
{
for(ii=0;ii<20;ii++)
for(jj=0;jj<20;jj++)
{
if(ii==0||ii==9||ii==19)
map[ii][jj]=1;
}
a=1;

}
if(level>=3&&snake.life<=5&&k==0)
lucky.yes=1;
if(lucky.yes==1)
{
lucky.x=rand()%400+60;
lucky.y=rand()%350+60;
while(lucky.x%10!=0)
lucky.x++;
while(lucky.y%10!=0)
lucky.y++;
for(ii=0;ii<20;ii++)
for(jj=0;jj<20;jj++)
if(map[ii][jj])
{

while(lucky.x==200+jj*10&&lucky.y==100+ii*10)
lucky.x+=10; /*不让救命稻草在内墙上出现*/
}

for(ii=0;ii<M;ii++)
{
while(lucky.x==food[ii].x&&lucky.y==food[ii].y)
lucky.x+=10;/*不让救命稻草与食物重合*/
}
for(ii=0;ii<F;ii++)
{
while(lucky.x==flower[ii].x&&lucky.y==flower[ii].y)
lucky.x+=10;/*不让救命稻草与毒花重合*/
}
lucky.yes=0;
k=1;

}
if(lucky.yes==0&&k==1)
{
setcolor(RED); /*救命稻草为红色*/
circle(lucky.x,lucky.y,4);

}

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=0;
break;
}
}
if(snake.x[0]<55||snake.x[0]>595||snake.y[0]<45||
snake.y[0]>455)/*蛇是否撞到外墙壁*/
{
GameOver();/*本次游戏结束*/
snake.life=0; /*蛇死*/
}
for(i=0;i<20;i++)
{
for(j=0;j<20;j++)
{
if(map[i][j])
{
if(snake.x[0]==(200+j*10)&&snake.y[0]==(100+i*10)) /*蛇是否撞到内墙壁*/
{
snake.life--;/*生命值减1*/
score-=10;
setcolor(0);
rectangle(200+j*10-5,100+i*10-5,210+j*10-5,110+i*10-5);/*去掉被撞掉的砖块*/
map[i][j]=0;/*清地图*/
PrScore();
}
}
}
}
if(snake.life==0)/*以上三种判断,如果蛇死就跳出内循环，重新开始*/
break;
for(i=0;i<M;i++)
{
if(snake.x[0]==food[i].x&&snake.y[0]==food[i].y)/*吃到食物以后*
{
setcolor(0);/*把画面上的食物东西去掉*/
circle(food[i].x,food[i].y,4);
snake.x[snake.node]=-20;snake.y[snake.node]=-20;
/*新的一节先放在看不见的位置,下次循环就取前一节的位置*/
snake.node++;/*蛇的身体长一节*/
food[i].yes=1;/*画面上需要出现新的食物*/
score+=10*level;
PrScore();/*输出新得分*/
}
}

for(i=0;i<F;i++)
{
if(snake.x[0]==flower[i].x&&snake.y[0]==flower[i].y)/*吃到毒花后*/
{
setcolor(0);
circle(flower[i].x,flower[i].y,4);
snake.life--;
flower[i].yes=1;
score-=20;
PrScore();
}
}

if(snake.x[0]==lucky.x&&snake.y[0]==lucky.y)/*吃到救命稻草后*/
{
setcolor(0);
circle(lucky.x,lucky.y,4);
snake.life++;
score+=100;
PrScore();
k=0;
}

level=snake.node/10+1;
gamespeed=60000-level*5000;

for(i=0;i<snake.node;i++)
{
setcolor(i%15+1);
/*画出彩蛇*/

circle(snake.x[i],snake.y[i],5);
}
delay(gamespeed);
setcolor(0);/*用黑色去除蛇的的最后一节*/
circle(snake.x[snake.node-1],snake.y[snake.node-1],5);
} /*endwhile（！kbhit）*/
if(snake.life==0)/*如果蛇死就跳出循环*/
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],str1[10];
char str2[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);
setfillstyle(SOLID_FILL,YELLOW);
bar(225,15,350,35);
setcolor(1);
sprintf(str1,"level:%d",level);
outtextxy(230,20,str1);
setfillstyle(SOLID_FILL,YELLOW);
bar(355,15,470,35);
setcolor(7);
sprintf(str2,"life:%d",snake.life);
outtextxy(360,20,str2);

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

㈩ C语言程序设计贪吃蛇

5分太少了，更何况还要每行标出注释，这就更不太可能了！不过估计你的分数自己也不多了，到我的网盘下载代码吧，不是每行都有注释，但注释也算详细了，只是文件调用存储两个函数没有写注释，看看合适不？