C语言实现控制台版贪吃蛇游戏

用c语言写的期末作业：C语言实现控制台版贪吃蛇游戏的具体代码，供大家参考，具体内容如下
				?

									/*

									{

									 conio.h

									 阻塞式： getch()：   从无回显的控制台获取字符。无缓冲区，只有当按下一个键才会执行后面的程序。

									 非阻塞式： kbhit()    检测缓冲区中是否有字符；执行该函数后程序不会停下，而是继续执行下面的代码

									 由于getch()和kbhit()已弃用，

									 在编译时会产生警告，

									 可以用_getch()和_kbhit()替换它们，

									 或者在包含头文件前加上#pragma warning(disable : 4996)关闭警告

									}

									*/

									#pragma warning(disable : 4996)   //用来关闭警告

									#include<stdio.h>

									#include <stdlib.h>

									#include <conio.h>   //_kbhit()函数获取键盘事件

									#include <time.h>

									#include<Windows.h>

									#define WIN_HEIGH  30   //窗口高度

									#define WIN_WIDTH 105   //窗口宽度

									#define G_HEIGHT  30   //游戏界面高度

									#define G_WIDTH 80    //游戏界面宽度

									#define STATUS int    //函数返回状态属性

									#define SUCCESS 1    //执行成功

									#define FAIL 0     //执行失败

									typedef struct snake_node{    //蛇的某个点的信息

									 char direct;    //即将前进的方向  udlr分别对应上下左右，刚吃掉的身体部分方向为o

									 COORD postion;    //该点所在位置

									 struct snake_node* next_node;  //下个节点的指针

									}*Ps_node,S_node;

									typedef struct snake {

									 char head_type;   //蛇头的样子

									 char body_type;   //蛇身的样子

									 WORD color;    //颜色

									 int level;    //等级

									 int speed;    //速度

									 int score;    //成绩

									 int control;   //控制器 即按wasd进行移动，或者按上下左右进行移动 

									 S_node head;   //蛇头

									}*Psnake,Snake;    //蛇结构

									// 0输出空格 -1输出#

									char canvas[G_HEIGHT][G_WIDTH] ; //画布

									int bean_count;      //已创建食物的数量

									POINT reward_position;    //奖励的位置

									int reward_time = -1000;   //奖励剩余时间

									int run_snake_threads;    //正在运行的蛇的数量

									char keyboard_out[2];    //键盘的输出控制器 keyboard_out[0],代表控制器1，keyboard_out[1],代表控制器2，

									int init_snake_speed = 400;   //蛇的初始速度 ,例=400时，蛇0.4s前进一步

									//关于颜色取值，请查看help.txt

									void gotoxy(int x, int y);           //设置光标到指定位置

									void setcolor(WORD wAttributes);         //设置输出颜色

									void prc_toxy(char c, int x, int y);        //指定位置输出字符

									void prs_toxy(char* str, int x, int y);        //指定位置输出字符串

									void prc_colortoxy(char str, int x, int y, WORD wAttributes);  //在指定位置，以wAttributes颜色输出字符 

									void prs_colortoxy(char* str, int x, int y, WORD wAttributes);  //在指定位置，以wAttributes颜色输出字符字符串

									void one_play_mod();  //进入单人模式

									void two_play_mod();  //进入双人模式

									/***********************

									 函数名：init_system

									 功能：

									   获取窗口句柄

									   设置控制台颜色和大小

									   隐藏光标显示

									************************/

									void init_system();

									/***********************

									 函数名：init_snode

									 功能：初始化新的身体节点

									 输入参数：

									  direct:这个节点的下一个运动方向；

									  snake_x,snake_y:这个节点的位置(x,y)

									  next_node:下一个节点的指针

									 返回值：

									  Ps_node:返回已初始化的节点的指针

									************************/

									Ps_node init_snode(Ps_node n_snode,char drect,int x,int y,Ps_node next_node);

									/************************

									 函数名:init_snake

									 功能：初始化蛇的相关参数，并为其创建身体，长度为三

									 输入参数：

									   she:  要初始化的蛇指针

									   color:  蛇的颜色

									   head_type:  用该字符显示蛇的身体

									   x,y:  蛇最开始的位置

									   direct:  默认前进方向

									   control: 移动蛇的方式：默认1为WASD键，2为方向键盘上下左右键

									 返回值：初始化后的蛇指针

									**************************/

									Psnake init_snake(Psnake she ,WORD color,char head_type,char body_type,int x,int y, char direct, int control);  //初始化小蛇

									DWORD WINAPI Run_Snake_Thread(LPVOID lpParam);    //线程：运行一条蛇

									DWORD WINAPI Del_reward_Thread(LPVOID lpParam);    //线程：生成奖励后，一段时间内不迟到奖励会消失

									DWORD WINAPI Render_Thread(LPVOID lpParam);     //线程：用来渲染，游戏运行时，所有的打印显示由该进程完成

									DWORD WINAPI Keyboard_Thread(LPVOID lpParam);    //线程：游戏运行时，监听按键输入，并设置keyboard_out

									/************************

									 函数名:get_canvas_toxy

									 功能： 获取画布上该点的值

									 输入参数：postion 

									 返回值：char类型，画布上该点的值

									************************/

									char get_canvas_toxy(COORD postion);

									/***********************

									 函数名:snode_gonext

									 功能： 蛇身体上的点移动到下个位置

									 输入参数：

									  snode：要移动的点

									  direct:要移动的方向

									 返回值：char ,未移动前，该点要前进的方向

									************************/

									char snode_gonext(Ps_node snode, char direct);

									/***********************

									 函数名:snake_gonext

									 功能： 蛇移动到下个位置

									 输入参数：

									  she：要移动的蛇

									  direct：蛇头移动的方向

									 返回值：无

									************************/

									void snake_gonext(Psnake she, char direct);

									/********************

									 函数名：init_canvas

									 功能： 初始化画布，并为画布设置边框

									 输入参数： 无

									 返回值： 无

									********************/

									void init_canvas();

									void draw_wall();      //在canvas上设置边框位置

									/***********************

									 函数名:snaketocanvas

									 功能：将蛇的坐标信息拷贝到画布canvas上,在canvas上删除原来的位置信息,

									 输入参数：she ：要拷贝的蛇的指针

									***********************/

									void snaketocanvas(Psnake she);

									/**************************

									 函数名：eat_node

									 功能：蛇吃食物，并把它加入蛇身，并增加成绩，触发升级加速

									  (注：加入到蛇身后该点的位置还在原来的地方，需要身体都经过那里后长度才会增加)

									 输入参数：

									   she:吃食物的那条蛇

									   position：食物的位置

									**************************/

									void eat_node(Psnake she, COORD postion);

									/**********************

									 函数名：create_bean

									 功能：在画布的一个随机位置创建豆

									 返回值：

									   status：返回是否创建成功

									**********************/

									STATUS createrand_bean(); 

									/**********************

									 函数名：free_snake

									 功能：释放小蛇的内存

									 输入参数：

									   she：要释放内存的小蛇

									************************/

									void free_snake(Psnake she);

									void  menu();   //开始菜单， 用来选择模式，单人或者双人

									void show_menu(int flag);  //根据不同的flag显示不同的菜单

									HANDLE handle;

									int main() {

									 init_system();

									 menu();

									 return 0;

									}

									void init_system() {

									 system("color F0 ");

									 handle = GetStdHandle(STD_OUTPUT_HANDLE);//获取窗口句柄

									 char chCmd[32];

									 sprintf(chCmd, "mode con cols=%d lines=%d", WIN_WIDTH, WIN_HEIGH);  //设置控制台大小

									 system(chCmd);

									 CONSOLE_CURSOR_INFO cursor_info = { 1,0 };   //设置光标不可见，第一个值为光标厚度，第二个值为光标是否显示

									 SetConsoleCursorInfo(handle, &cursor_info);   // 

									 srand((int)time(NULL));        //初始化随机数种子

									}

									void menu() {

									 int ch1, ch2;

									 int flag = 1;  //标志当前选择模式

									 show_menu(flag);

									 while (1) {

									  ch1 = _getch();

									  if (ch1 == 13) {

									   printf("此处是进入函数\n");

									   if (flag == 1)

									    one_play_mod();

									   else if (flag == 2)

									    two_play_mod();

									   else {

									    system("cls");

									    printf("退出\n");

									    break;

									   }

									  }

									  if (ch1==224) {

									   ch2 = _getch();

									   if (ch2 == 72) {

									    flag = (flag + 2)% 3;

									   }

									   else if (ch2 == 80) {

									    flag = (flag + 4) % 3;

									   }

									  }

									  show_menu(flag);

									 }

									}

									void show_menu(int flag) {

									 char gamename[30] = "贪      吃      蛇";

									 char mod1[20] = "单人模式";

									 char mod2[20] = "双人模式";

									 char modexit[20] = "退出";

									 int xstr = (WIN_WIDTH - strlen(mod1)) / 2;   //要打印选项的位置x列

									 int ystr;           //要打印选项的位置y行

									 WORD color[3] = {0xf0,0xf0,0xf0};           //要设置的颜色

									 system("cls");

									 setcolor(0xf0);

									 prs_toxy(gamename, (WIN_WIDTH - strlen(gamename) )/ 2, 5);

									 color[flag] = FOREGROUND_RED | 0xf0;

									 prs_colortoxy(mod1, (WIN_WIDTH - strlen(mod1)) / 2, 11, color[1]);

									 prs_colortoxy(mod2, (WIN_WIDTH - strlen(mod2)) / 2, 13, color[2]);

									 prs_colortoxy(modexit, (WIN_WIDTH - strlen(modexit)) / 2, 15, color[0]);

									 if (flag == 1) ystr = 11; else if (flag == 2) ystr = 13; else ystr = 15;  //设置箭头位于哪一行

									 prs_colortoxy("→", xstr - 4, ystr, color[flag]);

									 gotoxy(0, 0);

									}

									void gotoxy(int x, int y) {

									 COORD pos;

									 pos.X = x;

									 pos.Y = y;

									 SetConsoleCursorPosition(handle, pos);

									}

									void setcolor(WORD wAttributes) {

									 SetConsoleTextAttribute(handle, wAttributes);

									}

									void prc_toxy(char c, int x, int y) {

									 gotoxy(x, y);

									 printf("%c", c);

									}

									void prs_toxy(char* str, int x, int y) {

									 gotoxy(x, y);

									 printf("%s", str);

									}

									void prc_colortoxy(char c, int x, int y, WORD wAttributes) {

									 gotoxy(x, y);

									 SetConsoleTextAttribute(handle, wAttributes);

									 printf("%c", c);

									}

									void prs_colortoxy(char* str, int x, int y, WORD wAttributes) {

									 gotoxy(x, y);

									 SetConsoleTextAttribute(handle, wAttributes);

									 printf("%s", str);

									}

									Ps_node init_snode(Ps_node n_snode, char drect, int x, int y, Ps_node next_node) {

									 n_snode->direct = drect;

									 n_snode->postion.X = x;

									 n_snode->postion.Y = y;

									 n_snode->next_node = next_node;

									 return n_snode;

									}

									Psnake init_snake(Psnake she , WORD color, char head_type, char body_type, int x, int y, char direct,int control) {

									 int ax=x,ay=y,bx=x,by=y;

									 she->head_type = head_type;

									 she->body_type = body_type;

									 she->color = color;

									 she->control = control; 

									 she->level = 1;

									 she->speed = init_snake_speed;

									 she->score = 0;

									 Ps_node s1 = (Ps_node)malloc(sizeof(S_node));

									 Ps_node s2 = (Ps_node)malloc(sizeof(S_node)); 

									 switch (direct)

									 {

									 case 'l':

									  ax = x + 2; bx = x + 1;

									  break;

									 case 'r':

									  ax = x - 2; bx = x - 1;

									  break;

									 case 'u':

									  ay = y + 2; by = y + 1;

									  break;

									 case 'd':

									  ay = y - 2; by = y - 1;

									  break;

									 default:

									  break;

									 }

									 init_snode(s2, direct, ax, ay, NULL);     //要根据方向设置下一个节点的位置

									 init_snode(s1, direct, bx , by, s2);

									 init_snode(&she->head, direct, x, y,s1);

									 return she;

									}

									void one_play_mod() {

									 HANDLE hThread;

									 HANDLE hThread_render;

									 HANDLE hT_getkey;

									 Snake xiaoshe;

									 system("cls");

									 bean_count = 0;

									 init_canvas();

									 init_snake(&xiaoshe,0xf2, '@','*', G_WIDTH/2, G_HEIGHT/2, 'r', 2);

									 snaketocanvas(&xiaoshe);

									 createrand_bean();

									 run_snake_threads = 1;

									 draw_wall();

									 hThread = CreateThread(NULL, 0, Run_Snake_Thread,(LPVOID)&xiaoshe, 0, NULL);

									 hThread_render = CreateThread(NULL, 0, Render_Thread, (LPVOID)&xiaoshe, 0, NULL);

									 hT_getkey= CreateThread(NULL, 0,Keyboard_Thread, NULL, 0, NULL);

									 WaitForSingleObject(hThread, INFINITE);

									 run_snake_threads = 0;

									 WaitForSingleObject(hT_getkey, INFINITE);

									 WaitForSingleObject(hThread_render, INFINITE);

									 CloseHandle(hThread);

									 CloseHandle(hT_getkey);

									 CloseHandle(hThread_render);

									 gotoxy(G_WIDTH / 2-2, G_HEIGHT / 2);

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

									 Sleep(2000);

									}

									void two_play_mod() {

									 HANDLE hThread_a;

									 HANDLE hThread_b;

									 HANDLE hThread_render;

									 HANDLE hT_getkey;

									 Snake she[2];

									 system("cls");

									 bean_count = 0;

									 init_canvas();

									 init_snake(&she[0], 0xf2, '@', '*', G_WIDTH / 2-4, G_HEIGHT / 2 -4, 'r', 2);

									 init_snake(&she[1], 0xE5, 'U', 'S', G_WIDTH / 2, G_HEIGHT / 2, 'l', 1);

									 snaketocanvas(&she[0]);

									 snaketocanvas(&she[1]);

									 draw_wall();

									 createrand_bean();

									 /*createrand_bean();  //创建多个食物

									 createrand_bean();

									 createrand_bean();*/

									 run_snake_threads = 2;

									 hThread_b = CreateThread(NULL, 0, Run_Snake_Thread, (LPVOID)&she[0], 0, NULL);

									 hThread_a = CreateThread(NULL, 0, Run_Snake_Thread, (LPVOID)&she[1], 0, NULL);

									 hThread_render= CreateThread(NULL, 0, Render_Thread, (LPVOID)&she, 0, NULL);

									 hT_getkey = CreateThread(NULL, 0, Keyboard_Thread, NULL, 0, NULL);

									 WaitForSingleObject(hThread_a, INFINITE);

									 WaitForSingleObject(hThread_b, INFINITE);

									 run_snake_threads = 0;

									 WaitForSingleObject(hT_getkey, INFINITE);

									 WaitForSingleObject(hThread_render, INFINITE);

									 CloseHandle(hThread_a);

									 CloseHandle(hThread_b);

									 CloseHandle(hT_getkey);

									 CloseHandle(hThread_render);

									 gotoxy(G_WIDTH / 2, G_HEIGHT / 2);

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

									 Sleep(1000);

									}

									DWORD WINAPI Keyboard_Thread(LPVOID lpParam) {

									 int ch1;

									 int ch2;

									 keyboard_out[0] = 'n'; keyboard_out[1] = 'n';  

									 while (run_snake_threads > 0) {

									  while (_kbhit())

									  {

									   ch1 = _getch();

									   switch (ch1)

									   {

									   case 'w':

									    keyboard_out[0] = 'u';

									    break;

									   case 's':

									    keyboard_out[0] = 'd';

									    break;

									   case 'd':

									    keyboard_out[0] = 'r';

									    break;

									   case 'a':

									    keyboard_out[0] = 'l';

									    break;

									   case 224:

									    ch2 = _getch();

									    switch (ch2)

									    {

									    case 72:

									     keyboard_out[1] = 'u';

									     break;

									    case 80:

									     keyboard_out[1] = 'd';

									     break;

									    case 77:

									     keyboard_out[1] = 'r';

									     break;

									    case 75:

									     keyboard_out[1] = 'l';

									     break;

									    default:

									     break;

									    }

									    break;

									   default:

									    break;

									   }

									  }

									  Sleep(50);

									 }

									}

									char get_canvas_toxy(COORD postion) {

									 return canvas[postion.Y][postion.X];

									}

									char snode_gonext(Ps_node snode, char direct) {

									 char old_direct = snode->direct;

									 snode->direct = direct;

									 switch (direct)

									 {

									 case 'u':

									  snode->postion.Y = snode->postion.Y - 1;

									  break;

									 case 'd':

									  snode->postion.Y = snode->postion.Y + 1;

									  break;

									 case 'l':

									  snode->postion.X = snode->postion.X - 1;

									  break;

									 case 'r':

									  snode->postion.X = snode->postion.X + 1;

									  break;

									 default:

									  break;

									 }

									 return old_direct;

									}

									void snake_gonext(Psnake she, char direct) {

									 Ps_node temp=&she->head;

									 Ps_node end = temp;

									 char dta=direct;   //方向

									 while (temp!=NULL)  //不处理最后一个节点

									 {

									  if(temp->next_node!=NULL && temp->next_node->direct=='n'){

									   if (temp->postion.X == temp->next_node->postion.X && temp->postion.Y == temp->next_node->postion.Y) {

									    dta = snode_gonext(temp, dta);

									    temp->next_node->direct = dta;

									   }else

									    dta = snode_gonext(temp, dta);

									   break;

									  }

									  dta=snode_gonext(temp, dta);

									  temp = temp->next_node;

									 }

									 snaketocanvas(she);

									}

									void snaketocanvas(Psnake she) {

									 Ps_node temp=&she->head;

									 int i, j,x,y;

									 char body_type = she->body_type;

									 for (i = 1; i < G_HEIGHT - 1; i++)

									  for (j = 1; j < G_WIDTH - 1; j++) 

									   if (canvas[i][j] == she->head_type || canvas[i][j] == she->body_type)

									    canvas[i][j] = '0';

									 x = temp->postion.X;

									 y = temp->postion.Y;

									 while (temp->next_node != NULL) {

									  canvas[temp->next_node->postion.Y][temp->next_node->postion.X] = body_type;

									  temp = temp->next_node;

									 }

									 canvas[y][x] = she->head_type;   //单独处理蛇头,放在最后防止被覆盖

									}

									void draw_wall() {

									 int i, j;

									 setcolor(0xf0);

									 gotoxy(0, 0);

									 for (i = 0; i < G_HEIGHT; i++) {

									  gotoxy(0, i);

									  for (j = 0; j < G_WIDTH; j++) {

									   if (canvas[i][j] == '#')

									    printf("#");

									   else

									    printf(" ");

									  }

									 }

									}

									DWORD WINAPI Render_Thread(LPVOID lpParam) {

									 Psnake shea = (Psnake)lpParam;

									 Psnake sheb = (run_snake_threads==2)?((Psnake)lpParam+1):(shea);

									 WORD color;

									 char heada = shea->head_type;

									 char headb = shea->head_type;

									 char pr;

									 char pr_score[50];

									 char show_time[30];

									 int snakes_counts = run_snake_threads;

									 int i, j;

									 if (snakes_counts == 1) {  //单人模式

									  prs_colortoxy("player 1", G_WIDTH + 3, 6, 0xf0);

									  prs_colortoxy("↑", G_WIDTH + 15, 5, 0xf0);

									  prs_colortoxy("←↓→",G_WIDTH + 13, 6, 0xf0);

									 }

									 else {

									  prs_colortoxy("player 1", G_WIDTH + 3, 6, 0xf0);

									  prs_colortoxy("↑", G_WIDTH + 15, 5, 0xf0);

									  prs_colortoxy("←↓→", G_WIDTH + 13, 6, 0xf0);

									  prs_colortoxy("player 2", G_WIDTH + 3, 19, 0xf0);

									  prs_colortoxy("W", G_WIDTH + 14, 18, 0xf0);

									  prs_colortoxy("ASD", G_WIDTH + 13, 19, 0xf0);

									 }

									 while (run_snake_threads != 0)  //根据snake线程数结束循环

									 {

									  for (i = 1; i < G_HEIGHT-1; i++) {

									   gotoxy(1, i);

									   for (j = 1; j < G_WIDTH-1; j++) {

									    switch (canvas[i][j])

									    {

									    case '@':   //蛇头

									     color = (heada == '@') ? shea->color : sheb->color;

									     pr = '@';

									     break;

									    case '*':   //蛇身

									     color = (shea->body_type == '*') ? shea->color : sheb->color;

									     pr = '*';

									     break;

									    case 'U':   //蛇头

									     color = (shea->head_type == 'U') ? shea->color : sheb->color;

									     pr = 'U';

									     break;

									    case 'S':   //蛇身

									     color = (shea->body_type == 'S') ? shea->color : sheb->color;

									     pr = 'S';

									     break;

									    case '$':   //豆子

									     color = 0xf6;

									     pr = '$';

									     break;

									    case '&':   //奖励

									     color = 0xa4;

									     pr = '&';

									     break;

									    case '0':

									     color = 0xf0;

									     pr = ' ';

									     break;

									    default:

									     break;

									    }

									    setcolor(color);

									    printf("%c", pr);

									   }

									  }

									  sprintf(pr_score, "分数：      %d", shea->score);

									  prs_colortoxy(pr_score, G_WIDTH + 3, 8, 0xf0);

									  if (snakes_counts == 2) {

									   sprintf(pr_score, "分数：      %d", sheb->score);

									   prs_colortoxy(pr_score, G_WIDTH + 3, 21, 0xf0);

									  }

									  if (reward_time >= 0) {

									   sprintf(show_time, "奖励剩余时间：%ds  ", reward_time / 1000);

									   prs_colortoxy(show_time, G_WIDTH + 5, G_HEIGHT - 3, 0xf4);

									  }

									  else {

									   prs_colortoxy("                    ", G_WIDTH + 5, G_HEIGHT - 3, 0xf4);

									  }

									  Sleep(50);  //显示频率

									 }

									}

									STATUS createrand_bean() {

									 int ran;  //canvas的第n个点为奖励位置

									 int i,j,count,sum=0;

									 char c = '$';

									 HANDLE delrewarthread;

									 for (i = 1; i < G_HEIGHT - 1; i++)

									  for (j = 1; j < G_WIDTH - 1; j++)

									   if (canvas[i][j] == '0') 

									    sum++;

									 if (sum == 0)

									  return FAIL;

									 if (bean_count % 5 == 0 && bean_count!=0) {

									  ran = rand() % sum;

									  count = 0;

									  for (i = 1; i < G_HEIGHT - 1; i++)

									   for (j = 1; j < G_WIDTH - 1; j++)

									    if (canvas[i][j] == '0') {

									     if (count == ran) {

									      reward_position.x = j;

									      reward_position.y = i;

									      canvas[i][j] = '&';

									      delrewarthread= CreateThread(NULL, 0, Del_reward_Thread, NULL, 0, NULL);

									      CloseHandle(delrewarthread);

									     }

									     count++;

									    }

									 }

									 bean_count++;

									 ran = rand() % sum;

									 count = 0;

									 for (i = 1; i < G_HEIGHT - 1; i++)

									  for (j = 1; j < G_WIDTH - 1; j++)

									   if (canvas[i][j] == '0') {

									    if (count == ran) {

									     canvas[i][j] = c;

									     return SUCCESS;

									    }

									    count++;

									   }

									 return FAIL;

									}

									void eat_node(Psnake she, COORD postion) {

									 Ps_node end = &she->head;

									 Ps_node s = (Ps_node)malloc(sizeof(S_node));

									 while (end->next_node != NULL)

									  end = end->next_node;

									 init_snode(s,'n', postion.X, postion.Y, NULL);

									 end->next_node = s;

									 canvas[postion.Y][postion.X]=she->head_type;

									 she->score++;

									 if (she->score / 10 >= she->level) {

									  she->level++;

									  she->speed = (int)(she->speed * 0.75);

									 }

									}

									void free_snake(Psnake she) {

									 Ps_node body = she->head.next_node;

									 Ps_node temp;

									 while (body!=NULL)

									 {

									  temp = body->next_node;

									  free(body);

									  body = temp;

									 }

									}

									DWORD WINAPI Run_Snake_Thread(LPVOID lpParam) {

									 Psnake pshe = (Psnake)lpParam;

									 char direct;

									 COORD next_node;   //下一个蛇头位置

									 char v_canvas;

									 boolean end = 0;

									 while (!end) {

									  direct = pshe->head.direct;

									  if (keyboard_out[pshe->control - 1] != 'n') {       //获取键盘输入的目的是，获取蛇要前往的下一个方向

									   switch (keyboard_out[pshe->control - 1])  //输入方向与运行方向相反

									   {

									   case 'u':

									    direct = (direct != 'd') ? 'u' : direct;

									    break;

									   case 'd':

									    direct = (direct != 'u') ? 'd' : direct;

									    break;

									   case 'l':

									    direct = (direct != 'r') ? 'l' : direct;

									    break;

									   case 'r':

									    direct = (direct != 'l') ? 'r' : direct;

									    break;

									   default:

									    break;

									   }

									   keyboard_out[pshe->control - 1] = 'n';

									  }

									  next_node = pshe->head.postion;

									  switch (direct)

									  {

									  case 'u':

									   next_node.Y = next_node.Y - 1;

									   break;

									  case 'd':

									   next_node.Y = next_node.Y + 1;

									   break;

									  case 'l':

									   next_node.X = next_node.X - 1;

									   break;

									  case 'r':

									   next_node.X = next_node.X + 1;

									   break;

									  default:

									   break;

									  }

									  v_canvas = get_canvas_toxy(next_node);

									  switch (v_canvas)

									  {

									  case '0':      //表示该点安全，没有东西

									   snake_gonext(pshe, direct);

									   break;

									  case '$':

									   eat_node(pshe, next_node);

									   snake_gonext(pshe, direct);

									   end = !createrand_bean();

									   break;

									  case '&':      //吃下道具，触发减速

									   eat_node(pshe, next_node);

									   snake_gonext(pshe, direct);

									   pshe->speed =(int) (pshe->speed * 1.25);

									   break;

									  default:

									   end = 1;

									   break;

									  }

									  Sleep(pshe->speed);

									 }

									 free_snake(pshe);  //这里只释放了蛇的身体其他信息仍保留

									 Sleep(500);

									 return 0;

									}

									DWORD WINAPI Del_reward_Thread(LPVOID lpParam) {

									 reward_time = 10000;

									 while (reward_time >=0)

									 {

									  if (canvas[reward_position.y][reward_position.x] == '&' && run_snake_threads>0) {

									   Sleep(1000);

									   reward_time = reward_time - 1000;

									  }

									  else

									   break;

									 }

									 canvas[reward_position.y][reward_position.x] = '0';

									 reward_time = -1000;

									 return 0;

									}

									void init_canvas() {

									 int i, j;

									 for (i = 0; i < G_HEIGHT; i++)

									  for (j = 0; j < G_WIDTH; j++) 

									   canvas[i][j] = '0';

									 for (i = 0; i < G_HEIGHT ; i++) {

									  canvas[i][0] = '#';

									  canvas[i][G_WIDTH - 1] = '#';

									 }

									 for (j = 0; j < G_WIDTH; j++) {

									  canvas[0][j] = '#';

									  canvas[G_HEIGHT  - 1][j] = '#';

									 }

									}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：https://blog.csdn.net/YiLiuF/article/details/108134110
C语言实现控制台版贪吃蛇游戏

相关文章

热门资讯
