• c语言贪吃蛇项目的实现

    ncurse的引入

    ncurse的概念

    ncurse(new curses)是一套编程库，它提供了一系列的函数，以便使用者调用它们去生成基于文本的用户界面。 ncurses是一个能提供功能键定义(快捷键),屏幕绘制以及基于文本终端的图形互动功能的动态库。ncurses用得最多的地方是linux内核编译之前的内核配置，ncurses早已淡出舞台，甚至体验感完爆ncurses的C图形库GTK、C++图形库QT也区趋于落伍嵌入式设备上的Android 系统。这个游戏只是使用ncurses并不以学习它为目的，主要还是通过这个游戏锻炼我们C语言的能力。

    ncurse的格式

    1. #include //记得包含头文件
    2.  
    3. int main()
    4. {
    5.         initscr();//ncurse界面的初始化函数
    6.         printw("this is a test:n");//在ncurse模式下的printf
    7.         getch();//等待用户输入，如果没有这句话，程序就退出来了，看不到运行结果，也就是看不到上面的那句话
    8.         endwin();//程序退出，调用改函数来恢复shell终端的显示，如果没有这句话，shell终端字乱码，会坏掉
    9.  
    10.         return 0;
    11. }

    ncurse的编译

    ncurse的编译需要在文件名.c后加-lcurses

    上述格式代码编译结果如下：

    nurses的上下左右键值获取及演示

    如果不用nurses，那么每次输入上下左右得输入回车小蛇才会有反应，而运用nurses只需输入上下左右小蛇便会做出反应，提高灵敏度，因为该项目键盘中只需用到上下左右，所以我们只需获得上下左右键值即可。

    进入nurses头文件方式

    vi /usr/include/curses.h

    上下左右键值宏定义

    1. #define KEY_DOWN        0402
    2. #define KEY_UP          0403
    3. #define KEY_LEFT        0404
    4. #define KEY_RIGHT       0405

    代码演示

    1. #include 
    2.  
    3. int main()
    4. {
    5.         int key;
    6.  
    7.         initscr();
    8.         keypad(stdscr,1);//函数调用→接受功能键,是否接收(1是接收)
    9.  
    10.         while(1)
    11.         {
    12.                 key = getch();
    13.                 switch(key)
    14.                 {
    15.                         case 0402:
    16.                                 printw("DOWN\n");
    17.                                 break;
    18.                         case 0403:
    19.                                 printw("UP\n");
    20.                                 break;
    21.                         case 0404:
    22.                                 printw("LEFT\n");
    23.                                 break;
    24.                         case 0405:
    25.                                 printw("RIGHT\n");
    26.                                 break;
    27.                 }
    28.         }
    29.  
    30.         endwin();
    31.  
    32.         return 0;
    33. }

    编译结果

    地图规划

    地图边界

    代码演示

    1. #include 
    2.  
    3. void gameMap()
    4. {
    5. 	int hang,lie;
    6.  
    7. 	for(hang = 0;hang <20;hang++)
    8. 	{
    9. 		if(hang == 0)
    10. 		{
    11. 			for(lie = 0;lie < 20;lie++)
    12. 			{
    13. 				printw("--");
    14. 			}
    15. 			printw("\n");
    16. 		}
    17.  
    18. 		if(hang >= 0 && hang <= 18)
    19. 		{	
    20. 			for(lie = 0;lie <= 20;lie++)
    21. 			{
    22. 				if(lie == 0 || lie == 20)
    23. 				{	
    24. 					printw("|");
    25. 				}
    26. 				else
    27. 				{
    28. 					printw("  ");
    29. 				}
    30. 			}
    31. 			printw("\n");
    32. 		}
    33.  
    34. 		if(hang == 19)
    35. 		{
    36. 			for(lie = 0;lie < 20;lie++)
    37. 			{	
    38. 				printw("--");
    39. 			}
    40. 			printw("\n");
    41. 		}	
    42. 	}	
    43. }
    44.  
    45. int main()
    46. {
    47. 	gameMap();
    48.  
    49. 	getch();
    50. 	endwin();
    51.  
    52. 	return 0;
    53. }

    代码运行结果：

    贪吃蛇节点身子

    代码演示

    1. #include 
    2. #include 
    3.  
    4. struct snakebody
    5. {
    6. 	int hang;
    7. 	int lie;
    8. 	struct snakebody *next;
    9. };
    10.  
    11. struct snakebody *head;
    12. struct snakebody *tail;
    13.  
    14. int snakeNode(int i,int j)
    15. {
    16. 	struct snakebody *p;
    17. 	p = head;//指向链表头
    18. 	while(p != NULL)
    19. 	{
    20. 		if(p->hang == i && p->lie == j)
    21. 		{
    22. 			return 1;
    23. 		}
    24. 		p = p->next;
    25. 	}
    26. 	return 0;
    27. }
    28.  
    29. void gameMap()
    30.  
    31. {
    32. 	int hang,lie;
    33.  
    34. 	for(hang = 0;hang <20;hang++)
    35. 	{
    36. 		if(hang == 0)
    37. 		{
    38. 			for(lie = 0;lie < 20;lie++)
    39. 			{
    40. 				printw("--");
    41. 			}
    42. 			printw("\n");
    43. 		}
    44.  
    45. 		if(hang >= 0 && hang <= 18)
    46. 		{	
    47. 			for(lie = 0;lie <= 20;lie++)
    48. 			{
    49. 				if(lie == 0 || lie == 20)
    50. 				{	
    51. 					printw("|");
    52. 				}
    53. 				else if(snakeNode(hang,lie))
    54. 				{
    55. 					printw("[]");//蛇结点身子的出现
    56. 				}
    57. 				else
    58. 				{
    59. 					printw("  ");
    60. 				}
    61. 			}
    62. 			printw("\n");
    63. 		}
    64.  
    65. 		if(hang == 19)
    66. 		{
    67. 			for(lie = 0;lie < 20;lie++)
    68. 			{	
    69. 				printw("--");
    70. 			}
    71. 			printw("\n");
    72. 		}	
    73. 	}	
    74. }
    75.  
    76. void addNode()
    77. {
    78. 	struct snakebody *new = (struct snakebody *)malloc(sizeof(struct snakebody));
    79. 	
    80. 	new->hang = tail->hang;
    81. 	new->lie = tail->lie+1;
    82. 	new->next = NULL;
    83. 	
    84. 	tail->next = new;//新的节点赋给尾的下一个
    85. 	tail = new;//当尾后面没有节点时，新节点就是尾
    86. }
    87.  
    88. void initSnake()//身子初始化
    89. {
    90. 	head = (struct snakebody *)malloc(sizeof(struct snakebody));
    91. 	head->hang = 2;
    92. 	head->lie = 2;
    93. 	head->next = NULL;
    94.  
    95. 	tail = head;//一开始头就是尾
    96.  
    97. 	addNode();//头已经定义 调用一次该函数，就是多一节
    98. 	addNode();
    99. 	addNode();
    100. }
    101.  
    102. int main()
    103. {
    104. 	initcurses();
    105. 	initSnake();
    106. 	
    107. 	gameMap();
    108.  
    109. 	getch();
    110. 	endwin();
    111.  
    112. 	return 0;
    113. }

    代码运行结果：

    贪吃蛇的移动和“复活”

    完成了地图规划就应该对蛇进行操控使得更加有体验感 接下来一步一步让代码使得体验更加逼真。

    实现贪吃蛇向右移动

    向右移动主要分为两个步骤：第一个是头结点删除，使得第二个结点成为头结点；第二个是新结点从尾部加入。代码如下：

    1. #include 
    2.  
    3. #include 
    4.  
    5. void gameMap()
    6.  
    7. {
    8. 	int hang,lie;
    9.  
    10. 	move(0,0);//每次偏移时在地图里展现出来
    11.  
    12.     for(hang = 0;hang <20;hang++)
    13. 	{
    14. 		if(hang == 0)
    15. 		{
    16. 			for(lie = 0;lie < 20;lie++)
    17. 			{
    18. 				printw("--");
    19. 			}
    20. 			printw("\n");
    21. 		}
    22.  
    23. 		if(hang >= 0 && hang <= 18)
    24. 		{	
    25. 			for(lie = 0;lie <= 20;lie++)
    26. 			{
    27. 				if(lie == 0 || lie == 20)
    28. 				{	
    29. 					printw("|");
    30. 				}
    31. 				else if(snakeNode(hang,lie))
    32. 				{
    33. 					printw("[]");
    34. 				}
    35. 				else
    36. 				{
    37. 					printw("  ");
    38. 				}
    39. 			}
    40. 			printw("\n");
    41. 		}
    42.  
    43. 		if(hang == 19)
    44. 		{
    45. 			for(lie = 0;lie < 20;lie++)
    46. 			{	
    47. 				printw("--");
    48. 			}
    49. 			printw("\n");
    50. 		}	
    51. 	}	
    52. }
    53.  
    54. void addNode()
    55. {
    56. 	struct snakebody *new = (struct snakebody *)malloc(sizeof(struct snakebody));
    57. 	
    58. 	new->hang = tail->hang;
    59. 	new->lie = tail->lie+1;
    60. 	new->next = NULL;
    61. 	
    62. 	tail->next = new;
    63. 	tail = new;
    64. }
    65.  
    66. void initSnake()
    67. {
    68. 	head = (struct snakebody *)malloc(sizeof(struct snakebody));
    69. 	head->hang = 2;
    70. 	head->lie = 2;
    71. 	head->next = NULL;
    72.  
    73. 	tail = head;
    74.  
    75. 	addNode();
    76. 	addNode();
    77. 	addNode();
    78. }
    79.  
    80. void deletNode()
    81. {
    82. 	struct snakebody *p;
    83. 	p = head;
    84.  
    85. 	head = head->next;//删除头结点
    86. 	free(p);//对删除的头结点进行空间内存释放
    87. }
    88.  
    89. void movesnake()
    90. {
    91. 	addNode();//在尾部增加结点
    92. 	deletNode();/调用删除头结点函数
    93. }
    94.  
    95. int main()
    96. {
    97. 	int control;
    98.  
    99. 	initcurses();
    100. 	initSnake();	
    101.  
    102. 	gameMap();
    103.  
    104. 	while(1)
    105. 	{	
    106. 		control = getch();
    107. 		if(control == KEY_RIGHT)
    108. 		{
    109. 			movesnake();
    110. 			gameMap();//偏移后刷新地图
    111. 		}
    112. 	}
    113.  
    114. 	getch();
    115. 	endwin();
    116.  
    117. 	return 0;
    118. }

    贪吃蛇撞墙回到起始位置

    这里先实现蛇在水平方向的偏移，如果蛇的尾结点碰到地图边界，则让其初始化。代码如下

    1. #include 
    2. #include 
    3.  
    4. void initcurses()
    5. {
    6. 	initscr();
    7. 	keypad(stdscr,1);
    8. }
    9.  
    10. struct snakebody
    11. {
    12. 	int hang;
    13. 	int lie;
    14. 	struct snakebody *next;
    15. };
    16.  
    17. struct snakebody *head = NULL;
    18. struct snakebody *tail = NULL;
    19.  
    20. int snakeNode(int i,int j)
    21. {
    22. 	struct snakebody *p;
    23. 	p = head;
    24. 	while(p != NULL)
    25. 	{
    26. 		if(p->hang == i && p->lie == j)
    27. 		{
    28. 			return 1;
    29. 		}
    30. 		p = p->next;
    31. 	}
    32. 	return 0;
    33. }
    34.  
    35. void gameMap()
    36.  
    37. {
    38. 	int hang,lie;
    39.  
    40. 	move(0,0);
    41.  
    42. 	for(hang = 0;hang <20;hang++)
    43. 	{
    44. 		if(hang == 0)
    45. 		{
    46. 			for(lie = 0;lie < 20;lie++)
    47. 			{
    48. 				printw("--");
    49. 			}
    50. 			printw("\n");
    51. 		}
    52.  
    53. 		if(hang >= 0 && hang <= 18)
    54. 		{	
    55. 			for(lie = 0;lie <= 20;lie++)
    56. 			{
    57. 				if(lie == 0 || lie == 20)
    58. 				{	
    59. 					printw("|");
    60. 				}
    61. 				else if(snakeNode(hang,lie))
    62. 				{
    63. 					printw("[]");
    64. 				}
    65. 				else
    66. 				{
    67. 					printw("  ");
    68. 				}
    69. 			}
    70. 			printw("\n");
    71. 		}
    72.  
    73. 		if(hang == 19)
    74. 		{
    75. 			for(lie = 0;lie < 20;lie++)
    76. 			{	
    77. 				printw("--");
    78. 			}
    79. 			printw("\n");
    80. 		}	
    81. 	}	
    82. }
    83.  
    84. void addNode()
    85. {
    86. 	struct snakebody *new = (struct snakebody *)malloc(sizeof(struct snakebody));
    87. 	
    88. 	new->hang = tail->hang;
    89. 	new->lie = tail->lie+1;
    90. 	new->next = NULL;
    91. 	
    92. 	tail->next = new;
    93. 	tail = new;
    94. }
    95.  
    96. void initSnake()
    97. {
    98. 	struct snakebody *p;
    99. 	
    100. 	while(head != NULL)//蛇撞墙后初始化时原来的身子还占内存空间，需对其进行释放
    101. 	{
    102. 		p = head;//指向链表头
    103. 		head = head->next;//遍历整个链表
    104. 		free(p);//释放整个链表内存空间
    105. 	}
    106.  
    107. 	head = (struct snakebody *)malloc(sizeof(struct snakebody));
    108. 	head->hang = 1;
    109. 	head->lie = 1;
    110. 	head->next = NULL;
    111.  
    112. 	tail = head;
    113.  
    114. 	addNode();
    115. 	addNode();
    116. 	addNode();
    117. }
    118.  
    119. void deletNode()
    120. {
    121. 	struct snakebody *p;
    122. 	p = head;
    123.  
    124. 	head = head->next;
    125. 	free(p);
    126. }
    127.  
    128. void movesnake()
    129. {	
    130. 	addNode();
    131. 	deletNode();
    132.  
    133. 	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20)
    134. 	{
    135. 		initSnake();//蛇撞到边界时初始化
    136. 	}
    137. }
    138.  
    139. int main()
    140. {
    141. 	int control;
    142.  
    143. 	initcurses();
    144. 	initSnake();	
    145.  
    146. 	gameMap();
    147.  
    148. 	while(1)
    149. 	{	
    150. 		control = getch();
    151. 		if(control == KEY_RIGHT)
    152. 		{
    153. 			movesnake();
    154. 			gameMap();
    155. 		}
    156. 	}
    157.  
    158. 	getch();
    159. 	endwin();
    160.  
    161. 	return 0;
    162. }

    贪吃蛇的自由移动

    线程的引入

    若要蛇的移动和按键检测同时进行，用两个while循环是无法实现的，其只会执行第一个循环中的内容，此时就得需要用到线程。线程是Linux中常见的函数库，在此项目中的作用是能够使两个循环同时进行。线程的定义格式是pthread_t+任意名字，创建线程格式是pthread_create(前面的任意名字取地址，NULL,循环的名字，NULL)同时线程有独自的头文件和链接库，如下：

    1. void* changeDir()
    2. {
    3.  
    4. }
    5.  
    6. pthread_t t1;
    7. pthread_create(&t1,NULL,changeDir,NULL);
    #include 
    gcc a.c -lcurses -lpthread

    自由移动代码演示：

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. #define UP      1
    6. #define DOWN   -1
    7. #define LEFT    2
    8. #define RIGHT  -2
    9.  
    10. void initcurses()
    11. {
    12. 	initscr();
    13. 	keypad(stdscr,1);
    14.     noecho();//ncurses自带的函数，作用是不让无关信息出现在显示屏上
    15. }
    16.  
    17. struct snakebody
    18. {
    19. 	int hang;
    20. 	int lie;
    21. 	struct snakebody *next;
    22. };
    23.  
    24. struct snakebody *head = NULL;
    25. struct snakebody *tail = NULL;
    26. int key;
    27. int dir;
    28.  
    29. int snakeNode(int i,int j)
    30. {
    31. 	struct snakebody *p;
    32. 	p = head;
    33. 	while(p != NULL)
    34. 	{
    35. 		if(p->hang == i && p->lie == j)
    36. 		{
    37. 			return 1;
    38. 		}
    39. 		p = p->next;
    40. 	}
    41. 	return 0;
    42. }
    43.  
    44. void gameMap()
    45.  
    46. {
    47. 	int hang,lie;
    48.  
    49. 	move(0,0);
    50.  
    51. 	for(hang = 0;hang <20;hang++)
    52. 	{
    53. 		if(hang == 0)
    54. 		{
    55. 			for(lie = 0;lie < 20;lie++)
    56. 			{
    57. 				printw("--");
    58. 			}
    59. 			printw("\n");
    60. 		}
    61.  
    62. 		if(hang >= 0 && hang <= 18)
    63. 		{	
    64. 			for(lie = 0;lie <= 20;lie++)
    65. 			{
    66. 				if(lie == 0 || lie == 20)
    67. 				{	
    68. 					printw("|");
    69. 				}
    70. 				else if(snakeNode(hang,lie))
    71. 				{
    72. 					printw("[]");
    73. 				}
    74. 				else
    75. 				{
    76. 					printw("  ");
    77. 				}
    78. 			}
    79. 			printw("\n");
    80. 		}
    81.  
    82. 		if(hang == 19)
    83. 		{
    84. 			for(lie = 0;lie < 20;lie++)
    85. 			{	
    86. 				printw("--");
    87. 			}
    88. 			printw("\n");
    89. 			printw("key=%d\n",key);
    90. 		}	
    91. 	}	
    92. }
    93.  
    94. void addNode()
    95. {
    96. 	struct snakebody *new = (struct snakebody *)malloc(sizeof(struct snakebody));
    97. 	new->next = NULL;
    98. 	switch(dir)
    99. 	{
    100. 		case UP:
    101. 			             new->hang = tail->hang-1;//蛇向上，行减一即可
    102.        			         new->lie = tail->lie;
    103. 			            break;
    104. 		case DOWN:
    105.                          new->hang = tail->hang+1;//蛇向下，行加一即可
    106.                          new->lie = tail->lie;
    107.                         break;
    108. 		case LEFT:
    109.                          new->hang = tail->hang;//蛇向左，列减一即可
    110.                          new->lie = tail->lie-1;
    111.                         break;
    112. 		case RIGHT:
    113.                          new->hang = tail->hang;//蛇向右，行加一即可
    114.                          new->lie = tail->lie+1;
    115.                         break;
    116.  
    117. 	}
    118. 	
    119. 	tail->next = new;
    120. 	tail = new;
    121. }
    122.  
    123. void initSnake()
    124. {
    125. 	struct snakebody *p;
    126. 	dir = RIGHT;
    127. 	while(head != NULL)
    128. 	{
    129. 		p = head;
    130. 		head = head->next;
    131. 		free(p);
    132. 	}
    133.  
    134. 	head = (struct snakebody *)malloc(sizeof(struct snakebody));
    135. 	head->hang = 1;
    136. 	head->lie = 1;
    137. 	head->next = NULL;
    138.  
    139. 	tail = head;
    140.  
    141. 	addNode();
    142. 	addNode();
    143. 	addNode();
    144. }
    145.  
    146. void deletNode()
    147. {
    148. 	struct snakebody *p;
    149. 	p = head;
    150.  
    151. 	head = head->next;
    152. 	free(p);
    153. }
    154.  
    155. void movesnake()
    156. {	
    157. 	addNode();
    158. 	deletNode();
    159.  
    160. 	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20)
    161. 	{
    162. 		initSnake();
    163. 	}
    164. }
    165.  
    166. void* refreshJiemian()
    167. {
    168. 	while(1)
    169.         {
    170.                 movesnake();
    171.                 gameMap();
    172.                 refresh();//ncurses自带刷新函数
    173.                 usleep(100000);//每个100000us向右移动一次
    174.         }
    175. 	
    176. }
    177.  
    178. void turn(int direction)
    179. {
    180. 	if(abs(dir) != abs(direction))//abs是一个运算符 表示的是参数的绝对值
    181.                     //如果输入方向的绝对值等于蛇前进方向的绝对值，则蛇的路径不发生改变
    182.                     //如果输入方向的绝对值不等于蛇前进方向的绝对值，则原有方向改变成输入方向
    183. 	{
    184. 		dir = direction;
    185. 	}
    186. }
    187.  
    188.  
    189. void* changeDir()
    190. {
    191. 	        while(1)
    192.         {
    193.                 key = getch();
    194.                 switch(key)
    195.                 {
    196.                         case 0402:
    197. 				                turn(DOWN);//调用turn函数，并将方向传过去，判断输入方向与原有方向绝对值是否一致
    198.                                 break;
    199.                         case 0403:
    200. 				                turn(UP);
    201.                                 break;
    202.                         case 0404:
    203. 				                turn(LEFT);
    204.                                 break;
    205.                         case 0405:
    206. 				                turn(RIGHT);
    207.                                 break;
    208.                 }
    209.         }
    210.  
    211.  
    212. }
    213.  
    214. int main()
    215. {
    216. 	pthread_t t1;
    217. 	pthread_t t2;
    218. 	
    219. 	initcurses();
    220. 	initSnake();	
    221.  
    222. 	gameMap();
    223.  
    224. 	pthread_create(&t1,NULL,refreshJiemian,NULL);
    225. 	pthread_create(&t2,NULL,changeDir,NULL);
    226. 	while(1);
    227.  
    228. 	getch();
    229. 	endwin();
    230.  
    231. 	return 0;
    232. }

    贪吃蛇的食物及"食"物(结尾)

    贪吃蛇食物关心的是其位置和符号，我们这里把符号定义为##，位置可以在蛇的身体结构体定义一个食物结构体，让食物的行、列在地图中被扫描，从而出现食物。食物的出现是随机的，这里需要调用一个函数，是rand()，其作用是生成一个随机数，定义格式在下面代码中展示，同时我们的地图是20x20，只需要使其范围在19以内(0开始)即可，这里运用取余的方法：行列都是20，让生成的随机数对20取余，即%20，那么出现的数的范围就在0到19(刚好为20倍数是为0)。"食"物的根本是判断蛇的尾部的行列值是否与食物行列值一致，如果一致则在吃到那一瞬间新增一个身体结点，不执行删除函数；如果不一致，则按原来一样自由移动。代码如下：

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. #define UP      1
    6. #define DOWN   -1
    7. #define LEFT    2
    8. #define RIGHT  -2
    9.  
    10. void initcurses()
    11. {
    12. 	initscr();
    13. 	keypad(stdscr,1);
    14. 	noecho();
    15. }
    16.  
    17. struct snakebody
    18. {
    19. 	int hang;
    20. 	int lie;
    21. 	struct snakebody *next;
    22. };
    23.  
    24. struct snakebody *head = NULL;
    25. struct snakebody *tail = NULL;
    26. int key;
    27. int dir;
    28. struct snakebody food;
    29.  
    30. void initfood()
    31. {
    32. 	int x = rand()%20;
    33. 	int y = rand()%20;
    34.  
    35. 	food.hang = x;
    36. 	food.lie = y;
    37. }
    38.  
    39. int snakeNode(int i,int j)
    40. {
    41. 	struct snakebody *p;
    42. 	p = head;
    43. 	while(p != NULL)
    44. 	{
    45. 		if(p->hang == i && p->lie == j)
    46. 		{
    47. 			return 1;
    48. 		}
    49. 		p = p->next;
    50. 	}
    51. 	return 0;
    52. }
    53.  
    54. int creatfood(int i,int j)
    55. {
    56.         if(food.hang == i && food.lie == j)//如果食物与传进来的参数行列值一样 就运行该函数 该函数主要用于后面地图出现食物符号
    57. 	    {
    58. 		    return 1;
    59.         }
    60.         return 0;
    61. }
    62.  
    63. void gameMap()
    64.  
    65. {
    66. 	int hang,lie;
    67.  
    68. 	move(0,0);
    69.  
    70. 	for(hang = 0;hang <20;hang++)
    71. 	{
    72. 		if(hang == 0)
    73. 		{
    74. 			for(lie = 0;lie < 20;lie++)
    75. 			{
    76. 				printw("--");
    77. 			}
    78. 			printw("\n");
    79. 		}
    80.  
    81. 		if(hang >= 0 && hang <= 18)
    82. 		{	
    83. 			for(lie = 0;lie <= 20;lie++)
    84. 			{
    85. 				if(lie == 0 || lie == 20)
    86. 				{	
    87. 					printw("|");
    88. 				}
    89. 				else if(snakeNode(hang,lie))
    90. 				{
    91. 					printw("[]");
    92. 				}
    93. 				else if(creatfood(hang,lie))
    94. 				{
    95. 					printw("##");//设置食物在地图出现
    96. 				}
    97. 				else
    98. 				{
    99. 					printw("  ");
    100. 				}
    101. 			}
    102. 			printw("\n");
    103. 		}
    104.  
    105. 		if(hang == 19)
    106. 		{
    107. 			for(lie = 0;lie < 20;lie++)
    108. 			{	
    109. 				printw("--");
    110. 			}
    111. 			printw("\n");
    112. 		}	
    113. 	}	
    114. }
    115.  
    116. void addNode()
    117. {
    118. 	struct snakebody *new = (struct snakebody *)malloc(sizeof(struct snakebody));
    119. 	new->next = NULL;	
    120. 	switch(dir)
    121. 	{
    122. 		case UP:
    123. 			 new->hang = tail->hang-1;
    124.        			 new->lie = tail->lie;
    125. 			break;
    126. 		case DOWN:
    127.                          new->hang = tail->hang+1;
    128.                          new->lie = tail->lie;
    129.                         break;
    130. 		case LEFT:
    131.                          new->hang = tail->hang;
    132.                          new->lie = tail->lie-1;
    133.                         break;
    134. 		case RIGHT:
    135.                          new->hang = tail->hang;
    136.                          new->lie = tail->lie+1;
    137.                         break;
    138.  
    139. 	}
    140. 	
    141. 	tail->next = new;
    142. 	tail = new;
    143. }
    144.  
    145. void initSnake()
    146. {
    147. 	struct snakebody *p;
    148. 	dir = RIGHT;
    149. 	while(head != NULL)
    150. 	{
    151. 		p = head;
    152. 		head = head->next;
    153. 		free(p);
    154. 	}
    155. 	initfood();
    156. 	head = (struct snakebody *)malloc(sizeof(struct snakebody));
    157. 	head->hang = 1;
    158. 	head->lie = 1;
    159. 	head->next = NULL;
    160.  
    161. 	tail = head;
    162.  
    163. 	addNode();
    164. 	addNode();
    165. 	addNode();
    166. }
    167.  
    168. void deletNode()
    169. {
    170. 	struct snakebody *p;
    171. 	p = head;
    172.  
    173. 	head = head->next;
    174. 	free(p);
    175. }
    176.  
    177. int ifSnakeDie()
    178. {
    179. 	struct snakebody *p;
    180. 	p = head;
    181. 	
    182. 	if(tail->hang < 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20)
    183.         {
    184.                 return 1;//碰到边界则运行该函数，该函数主要用于后面进行碰壁后蛇的初始化
    185.         }
    186. 	while(p->next != NULL)
    187. 	{
    188. 		if(p->hang == tail->hang && p->lie == tail->lie)
    189. 		{
    190. 			return 1;
    191. 		}
    192. 		p = p->next;
    193. 	}
    194. 	return 0;
    195. }
    196.  
    197.  
    198. void movesnake()
    199. {	
    200. 	addNode();
    201. 	if(creatfood(tail->hang,tail->lie))//将蛇的尾巴参数传到该函数 相当于蛇吃到食物 则初始化食物
    202. 	{
    203. 		initfood();
    204. 	}
    205. 	else
    206. 	{
    207. 		deletNode();
    208. 	}
    209. 	if(ifSnakeDie())
    210. 	{
    211. 		initSnake();
    212. 	}
    213. }
    214.  
    215. void* refreshJiemian()
    216. {
    217. 	while(1)
    218.         {
    219.                 movesnake();
    220.                 gameMap();
    221.                 refresh();
    222.                 usleep(100000);
    223.         }
    224. 	
    225. }
    226.  
    227. void turn(int direction)
    228. {
    229. 	if(abs(dir) != abs(direction))
    230. 	{
    231. 		dir = direction;
    232. 	}
    233. }
    234.  
    235. void* changeDir()
    236. {
    237. 	        while(1)
    238.         {
    239.                 key = getch();
    240.                 switch(key)
    241.                 {
    242.                         case 0402:
    243. 				turn(DOWN);
    244.                                 break;
    245.                         case 0403:
    246. 				turn(UP);
    247.                                 break;
    248.                         case 0404:
    249. 				turn(LEFT);
    250.                                 break;
    251.                         case 0405:
    252. 				turn(RIGHT);
    253.                                 break;
    254.                 }
    255.         }
    256.  
    257.  
    258. }
    259.  
    260. int main()
    261. {
    262. 	pthread_t t1;
    263. 	pthread_t t2;
    264. 	
    265. 	initcurses();
    266. 	initSnake();	
    267.  
    268. 	gameMap();
    269.  
    270. 	pthread_create(&t1,NULL,refreshJiemian,NULL);
    271. 	pthread_create(&t2,NULL,changeDir,NULL);
    272. 	while(1);
    273.  
    274. 	getch();
    275. 	endwin();
    276.  
    277. 	return 0;
    278. }

  • 相关阅读:
    CleanMyMac X2023测评是不是恶意软件?
    wps快速生成目录及页码设置（自备）
    LeetCode-高频 SQL 50 题：查询 篇
    c++编程实例
    01【什么是设计模式】
    REACT全家桶（4）----组件
    人脸识别技术，如何解决学校门禁安全？
    实验十七：模拟霍尔传感器实验
    《中学科技》是什么级别的刊物？如何投稿？
    爱创科技携手洽洽食品，探索渠道数字化最优解！
  • 原文地址：https://blog.csdn.net/2301_78772787/article/details/134249651