• C语言——贪吃蛇小游戏

    目录

    一、ncurse

    1.1 为什么需要用ncurse：

    1.2 ncurse的输入输出：

    1.2.1 如何使用ncurse：

    1.2.2 编译ncurse的程序：

    1.2.3 测试输入一个按键ncurse的响应速度：

    1.3 ncurse上下左右键获取：

    1.3.1 如何查看宏定义的.h文件：

    1.3.2 ncurse上下左右键获取：

    二、地图规划

    2.1 地图规划算法显示第一行：

    2.2 实现贪吃蛇完整地图：

    2.3 优化贪吃蛇地图：

    三、显示贪吃蛇身子

    3.1 显示贪吃蛇身子的一个节点：

    3.2 显示贪吃蛇完整身子：

    3.3 显示贪吃蛇完整身子改进：

    四、贪吃蛇移动

    4.1 按下▶贪吃蛇向右移动：

    4.2 贪吃蛇撞墙重新开始： 

    4.3 贪吃蛇脱缰自由向右行走

    五、Linux线程引入

    5.1 贪吃蛇方向移动和刷新界面一起实现面临的问题：

    5.2 线程的基本用法：

    5.3 线程demo案例：

    5.4 使用线程解决贪吃蛇方向移动和刷新界面一起实现面临的问题：

    六、贪吃蛇跑起来

    6.1 实现贪吃蛇四方向的风骚走位：

    6.2 用绝对值方式来解决不合理的走位：

    6.3 贪吃蛇吃饭了（食物的位置是随机的）：

    七、项目代码

    • 项目运行环境：Linux，基于Ncurse图形库的C语言小游戏

    • 项目的目的和意义：起到承上启下的作用，对于前面学的C语言的基础和数据结构链表做一个比较好的巩固，对于后面的Linux系统编程的开发做铺垫

    • 项目基础要求：C语言基础、Linux基本操作

      1. /*项目步骤*/
      2. （1）选择ncurses库的原因
      3. 在进行贪吃蛇游戏时，贪吃蛇的行进方向需要你按下上下左右键进行操控，如果使用C语言自带的函数，例如：scanf或者getchar之类的，需要你按下回车键，程序才能进行响应，而这显然是十分不方便的，但是ncurses库就很好的解决了这个问题。ncurses库自带的函数getch就能实现迅速便捷的贪吃蛇方向响应。
      4.  
      5. （2）ncurses库的基本入门
      6. 对于该项目而言，ncurses库我们不需要进行过于深入的学习，只需要知道一些基本的函数使用即可。下列程序中的函数，就是一个基于ncurses库的基本代码框架。
      7. #include 
      8.  
      9. int main()
      10. {
      11.         initscr();//ncurse界面的初始化函数
      12.         printw("this is a curses window\n");//在ncurse模式下的printf
      13.         getch();//等待用户的输入，如果没有这句话，程序就退出了，看不到运行的结果，也就是无法看到上面那句话
      14.         endwin();//程序退出，恢复shell终端的显示，如果没有这句话，shell终端字乱码，坏掉
      15.  
      16.         return 0;
      17. }
      18.  
      19. （3）贪吃蛇地图的整体规划
      20. 整个贪吃蛇地图的大小将它设置成一个20*20的近似正方形，使用"|"来表示左右边框，使用"--"来表示上下边框。
      21.  
      22. （4）实现贪吃蛇第一个节点的显示
      23.     
      24. （5）显示贪吃蛇的完整身子
      25. 注意，在这里，我们设置两个全局变量，struct Snake *head和struct Snake *tail，一个指向贪吃蛇的头，一个指向贪吃蛇的尾。在将第一个节点打印完后，将尾指向头，即：head = tail。每一次节点的添加，我们调用一个单独的函数去执行，并其使用尾插法实现。
      26.  
      27. （6）实现贪吃蛇的右移
      28. 贪吃蛇的移动，整体来说就是链表节点的删除与添加。我们首先实现贪吃蛇的右移，每当按键按下时，贪吃蛇右移一格，即左侧的头结点删除head = head->next，右侧再次添加一个新的节点。新节点的坐标应该是行不变，列加一。注意：不要忘记清楚垃圾节点。
      29.  
      30. （7）实现贪吃蛇的撞墙死亡
      31. 将贪吃蛇的尾节点坐标进行判断，判断其是否达到边界坐标。满足条件时，将贪吃蛇重新初始化。注意：不要忘记清楚垃圾节点。
      32.  
      33. （8）实现贪吃蛇的自由行走
      34. 在这里，我们发现了一个问题，地图需要实时刷新进行贪吃蛇位置的变更，这是一个while(1)的死循环，而获取键值也是一个实时读取的操作，因此也是一个while(1)死循环，代码执行逻辑上出现了问题，所以我们引入了线程的概念。
      35.  
      36. （9）了解什么是线程
      37.     
      38. （10）用线程解决上述问题，实现贪吃蛇的分骚走位
      39. 开辟两个线程，一个用来执行地图刷新操作，一个用来获取键值。
      40.  pthread_create(&t1,NULL,refreshScreen,NULL);
      41.  pthread_create(&t2,NULL,changeDir,NULL);
      42.  
      43. （11）解决贪吃蛇的不合理走位
      44. 在这里，我们使用绝对值法来解决问题，abs函数的作用便是取绝对值，我们将上下左右键，两两对应，宏定义为1，-1,2，-2之类的数就能成功解决问题。
      45.  
      46. （12）实现贪吃蛇食物的打印
      47.     
      48. （13）实现食物的随机出现
      49. 取随机数，C语言有一个自带的函数可以解决这个问题，rand()函数可以实现随机取数，我们只要再对它进行取余操作，便可以防止食物出现在地图以外的位置。
      50.  
      51. （14）实现贪吃蛇咬到自己结束游戏，重新开始的操作
      52. 当贪吃蛇的尾节点与自身除尾巴节点以外的其他节点进行比较后，若行列数相同，则初始化整个贪吃蛇，注意：不要忘记垃圾节点的清除（我们可以在每次贪吃蛇初始化之前进行这个操作）。

      一、ncurse

      1.1 为什么需要用ncurse：

    • 因为的按键响应牛逼哄哄

    • 1.2 ncurse的输入输出：

    • ncurse用的最多的地方是在Linux内核编译之前的内核配置

    • 1.2.1 如何使用ncurse：

    1.2.2 编译ncurse的程序：

    1.2.3 测试输入一个按键ncurse的响应速度：
    1. 1 #include 
    2.   2 
    3.   3 int main()
    4.   4 {
    5.   5         char c;
    6.   6 
    7.   7         initscr();
    8.   8         c = getch();
    9.   9         printw("you Input :%c\n",c);
    10.  10         getch();
    11.  11         endwin();
    12.  12         return 0;
    13.  13 }

    • 使用ncurse的好处是：按下一个按键不需要按下回车，直接就可以输出c的值，和我们C语言的其他输入函数好用

    1.3 ncurse上下左右键获取：

    1.3.1 如何查看宏定义的.h文件：

    vi /usr/include/curses.h    //查看宏定义.h文件的指令
    :q                            //退出查看

    1.3.2 ncurse上下左右键获取：

    1.  1 #include 
    2.   2 
    3.   3 int main()
    4.   4 {
    5.   5         int key;
    6.   6 
    7.   7         initscr();
    8.   8         keypad(stdscr,1);	//这个函数允许使用功能键，例如：F1、F2、方向键等功能键。几乎所有的交互式程序都需要使用功能			键，因为绝大多数用户界面主要用方向键进行操作。使用keypad(stdscr,TURE)就为“标准屏幕”（stdscr）激活了功能键。
    9.   9 
    10.  10         while(1){
    11.  11                 key = getch();
    12.  12                 switch(key){
    13.  13                         case KEY_DOWN:
    14.  14                                 printw("DOWN\n");
    15.  15                                 break;
    16.  16                         case KEY_UP:
    17.  17                                 printw("up\n");
    18.  18                                 break;
    19.  19                         case KEY_LEFT:
    20.  20                                 printw("LEFT\n");
    21.  21                                 break;
    22.  22                         case KEY_RIGHT:
    23.  23                                 printw("RIGHT\n");
    24.  24                                 break;
    25.  25                 }
    26.  26 
    27.  27 
    28.  28         }
    29.  29         endwin();
    30.  30         return 0;
    31.  31 }

    • 我们按下上下左右▲▼◀▶之后，可以获取到上下左右的打印信息

    二、地图规划

    2.1 地图规划算法显示第一行：

    1. #include 
    2.  
    3. void initNcurse()
    4. {
    5. 	initscr();
    6. 	keypad(stdscr,1);
    7. }
    8.  
    9. void gamPic()
    10. {
    11. 	int hang;
    12. 	int lie;
    13. 	
    14. 	for(hang=0; hang<20; hang++){
    15. 		if(hang == 0){
    16. 			for(lie=0; lie<20; lie++){
    17. 				printw("--");
    18. 			}
    19. 			printw("\n");
    20. 			for(lie=0; lie<=20; lie++){
    21. 				if(lie == 0 || lie == 20){
    22. 					printw("|");
    23. 				}else{
    24. 					printw("  ");
    25. 				}
    26. 			}
    27. 		}
    28. 	}
    29. }
    30.  
    31. int main()
    32. {
    33. 	initNcurse();	//初始化Ncurse
    34. 	gamPic();		//地图规划显示第一行
    35. 	
    36. 	getch();
    37. 	endwin();
    38. 	return 0;
    39. }

    2.2 实现贪吃蛇完整地图：

    1. #include 
    2.  
    3. void initNcurse()
    4. {
    5. 	initscr();
    6. 	keypad(stdscr,1);
    7. }
    8.  
    9. void gamPic()
    10. {
    11. 	int hang;
    12. 	int lie;
    13. 	
    14. 	for(hang=0; hang<20; hang++){
    15. 		if(hang == 0){
    16. 			for(lie=0; lie<20; lie++){
    17. 				printw("--");
    18. 			}
    19. 			printw("\n");
    20. 			for(lie=0; lie<=20; lie++){
    21. 				if(lie == 0 || lie == 20){
    22. 					printw("|");
    23. 				}else{
    24. 					printw("  ");
    25. 				}
    26. 			}
    27. 			printw("\n");
    28. 		}
    29. 		
    30. 		if(hang>0 && hang<=19) {
    31. 			for(lie=0; lie<=20; lie++){
    32. 				if(lie == 0 || lie == 20){
    33. 					printw("|");
    34. 				}else{
    35. 					printw("  ");
    36. 				}
    37. 			}
    38. 			printw("\n");
    39. 		}
    40.  
    41. 		if(hang == 19){
    42. 			for(lie=0; lie<20; lie++){
    43. 				printw("--");
    44. 			}
    45. 			printw("\n");
    46. 			printw("By ShiYaHao!\n");
    47. 		}
    48. 	}
    49. }
    50.  
    51. int main()
    52. {
    53. 	initNcurse();	//初始化Ncurse
    54. 	gamPic();		//实现贪吃蛇地图
    55. 	
    56. 	getch();
    57. 	endwin();
    58. 	return 0;
    59. }

    2.3 优化贪吃蛇地图：

    1. #include 
    2.  
    3. void initNcurse()
    4. {
    5. 	initscr();
    6. 	keypad(stdscr,1);
    7. }
    8.  
    9. void gamPic()
    10. {
    11. 	int hang;
    12. 	int lie;
    13. 	
    14. 	for(hang=0; hang<20; hang++){
    15. 		if(hang == 0){						//第0行打“--”
    16. 			for(lie=0; lie<20; lie++){
    17. 				printw("--");
    18. 			}
    19. 			printw("\n");
    20. 		}
    21. 		
    22. 		if(hang>=0 && hang<=19) {			//第0行-19行的第0列和第20列打“|”
    23. 			for(lie=0; lie<=20; lie++){
    24. 				if(lie == 0 || lie == 20){
    25. 					printw("|");
    26. 				}else{
    27. 					printw("  ");
    28. 				}
    29. 			}
    30. 			printw("\n");
    31. 		}
    32.  
    33. 		if(hang == 19){						//第19行打“--”
    34. 			for(lie=0; lie<20; lie++){
    35. 				printw("--");
    36. 			}
    37. 			printw("\n");
    38. 			printw("By ShiYaHao!\n");		//作者
    39. 		}
    40. 	}
    41. }
    42.  
    43. int main()
    44. {
    45. 	initNcurse();
    46. 	gamPic();
    47. 	
    48. 	getch();
    49. 	endwin();
    50. 	return 0;
    51. }
    52. //实现的贪吃蛇地图和上面一样，只不过是优化了一下代码

    三、显示贪吃蛇身子

    3.1 显示贪吃蛇身子的一个节点：

    1. #include 
    2.  
    3. struct Snake
    4. {
    5. 	int hang;
    6. 	int lie;
    7. 	struct Snake *next;
    8. };
    9.  
    10. struct Snake node1 = {2,2,NULL};
    11.  
    12. void initNcurse()
    13. {
    14. 	initscr();
    15. 	keypad(stdscr,1);
    16. }
    17.  
    18. void gamPic()
    19. {
    20. 	int hang;
    21. 	int lie;
    22. 	
    23. 	for(hang=0; hang<20; hang++){
    24. 		if(hang == 0){
    25. 			for(lie=0; lie<20; lie++){
    26. 				printw("--");
    27. 			}
    28. 			printw("\n");
    29. 		}
    30. 		
    31. 		if(hang>=0 && hang<=19) {
    32. 			for(lie=0; lie<=20; lie++){
    33. 				if(lie == 0 || lie == 20){
    34. 					printw("|");
    35. 				}else if(node1.hang == hang && node1.lie == lie){
    36. 					printw("[]");
    37. 				}else{
    38. 					printw("  ");
    39. 				}
    40. 			}
    41. 			printw("\n");
    42. 		}
    43.  
    44. 		if(hang == 19){
    45. 			for(lie=0; lie<20; lie++){
    46. 				printw("--");
    47. 			}
    48. 			printw("\n");
    49. 			printw("By ShiYaHao!\n");
    50. 		}
    51. 	}
    52. }
    53.  
    54. int main()
    55. {
    56. 	initNcurse();
    57. 	gamPic();
    58. 	
    59. 	getch();
    60. 	endwin();
    61. 	return 0;
    62. }

    3.2 显示贪吃蛇完整身子：

    1. #include 
    2.  
    3. struct Snake
    4. {
    5. 	int hang;
    6. 	int lie;
    7. 	struct Snake *next;
    8. };
    9.  
    10. struct Snake node1 = {2,2,NULL};
    11. struct Snake node2 = {2,3,NULL};
    12. struct Snake node3 = {2,4,NULL};
    13. struct Snake node4 = {2,5,NULL};
    14.  
    15. void initNcurse()
    16. {
    17. 	initscr();
    18. 	keypad(stdscr,1);
    19. }
    20.  
    21. int hasSnakeNode(int i, int j)
    22. {
    23. 	struct Snake *p = &node1;
    24.  
    25. 	while(p != NULL){
    26. 		if(p->hang == i && p->lie == j){
    27. 			return 1;
    28. 		}
    29. 		p = p->next;
    30. 	}
    31. 	return 0;
    32. }
    33.  
    34. void gamPic()
    35. {
    36. 	int hang;
    37. 	int lie;
    38. 	
    39. 	for(hang=0; hang<20; hang++){
    40. 		if(hang == 0){
    41. 			for(lie=0; lie<20; lie++){
    42. 				printw("--");
    43. 			}
    44. 			printw("\n");
    45. 		}
    46. 		
    47. 		if(hang>=0 && hang<=19) {
    48. 			for(lie=0; lie<=20; lie++){
    49. 				if(lie == 0 || lie == 20){
    50. 					printw("|");
    51. 				}else if(hasSnakeNode(hang,lie)){
    52. 					printw("[]");
    53. 				}else{
    54. 					printw("  ");
    55. 				}
    56. 			}
    57. 			printw("\n");
    58. 		}
    59.  
    60. 		if(hang == 19){
    61. 			for(lie=0; lie<20; lie++){
    62. 				printw("--");
    63. 			}
    64. 			printw("\n");
    65. 			printw("By ShiYaHao!\n");
    66. 		}
    67. 	}
    68. }
    69.  
    70. int main()
    71. {
    72. 	initNcurse();
    73.  
    74. 	node1.next = &node2;
    75. 	node2.next = &node3;
    76. 	node3.next = &node4;
    77.  
    78. 	gamPic();
    79. 	
    80. 	getch();
    81. 	endwin();
    82. 	return 0;
    83. }

    3.3 显示贪吃蛇完整身子改进：

    1. #include 
    2. #include 
    3.  
    4. struct Snake
    5. {
    6. 	int hang;
    7. 	int lie;
    8. 	struct Snake *next;
    9. };
    10.  
    11. struct Snake *head = NULL;	//指向链表头
    12. struct Snake *tail = NULL;	//指向链表尾
    13.  
    14. void initNcurse()
    15. {
    16. 	initscr();
    17. 	keypad(stdscr,1);
    18. }
    19.  
    20. int hasSnakeNode(int i, int j)
    21. {
    22. 	struct Snake *p = head;
    23.  
    24. 	while(p != NULL){
    25. 		if(p->hang == i && p->lie == j){
    26. 			return 1;
    27. 		}
    28. 		p = p->next;
    29. 	}
    30. 	return 0;
    31. }
    32.  
    33. void gamPic()				//地图规划
    34. {
    35. 	int hang;
    36. 	int lie;
    37. 	
    38. 	for(hang=0; hang<20; hang++){
    39. 		if(hang == 0){
    40. 			for(lie=0; lie<20; lie++){
    41. 				printw("--");
    42. 			}
    43. 			printw("\n");
    44. 		}
    45. 		
    46. 		if(hang>=0 && hang<=19) {
    47. 			for(lie=0; lie<=20; lie++){
    48. 				if(lie == 0 || lie == 20){
    49. 					printw("|");
    50. 				}else if(hasSnakeNode(hang,lie)){
    51. 					printw("[]");
    52. 				}else{
    53. 					printw("  ");
    54. 				}
    55. 			}
    56. 			printw("\n");
    57. 		}
    58.  
    59. 		if(hang == 19){
    60. 			for(lie=0; lie<20; lie++){
    61. 				printw("--");
    62. 			}
    63. 			printw("\n");
    64. 			printw("By ShiYaHao!\n");
    65. 		}
    66. 	}
    67. }
    68.  
    69. void addNode()
    70. {
    71. 	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));	//创建新节点
    72. 	if(new == NULL){
    73. 		printw("malloc error\n");
    74. 	}
    75. 	new->hang = tail->hang;		//新节点的行等于链表尾的行
    76. 	new->lie  = tail->lie+1;	//新节点的行等于链表尾的列+1
    77. 	new->next = NULL;
    78.  
    79. 	tail->next = new;			//从链表尾部插入新节点
    80. 	tail = new;					//新节点当作尾部
    81. }
    82.  
    83. void initSnake()
    84. {
    85. 	head = (struct Snake *)malloc(sizeof(struct Snake));	//创建链表头
    86. 	if(head == NULL){
    87. 		printw("malloc error\n");
    88. 	}
    89. 	head->hang = 2;			
    90. 	head->lie = 2;
    91. 	head->next = NULL;
    92.  
    93. 	tail = head;		//第一个节点链表头和链表尾是一样的
    94.  
    95. 	addNode();			//调用一次代表增加一个节点
    96. 	addNode();
    97. 	addNode();
    98. }
    99.  
    100. int main()
    101. {
    102. 	initNcurse();
    103. 	
    104. 	initSnake();
    105.  
    106. 	gamPic();
    107. 	
    108. 	getch();
    109. 	endwin();
    110. 	return 0;
    111. }

    四、贪吃蛇移动

    4.1 按下▶贪吃蛇向右移动：

    1. #include 
    2. #include 
    3.  
    4. struct Snake
    5. {
    6. 	int hang;
    7. 	int lie;
    8. 	struct Snake *next;
    9. };
    10.  
    11. struct Snake *head = NULL;
    12. struct Snake *tail = NULL;
    13.  
    14. void initNcurse()
    15. {
    16. 	initscr();
    17. 	keypad(stdscr,1);
    18. }
    19.  
    20. int hasSnakeNode(int i, int j)
    21. {
    22. 	struct Snake *p = head;
    23.  
    24. 	while(p != NULL){
    25. 		if(p->hang == i && p->lie == j){
    26. 			return 1;
    27. 		}
    28. 		p = p->next;
    29. 	}
    30. 	return 0;
    31. }
    32.  
    33. void gamPic()
    34. {
    35. 	int hang;
    36. 	int lie;
    37. 	
    38. 	move(0,0);
    39. 		
    40. 	for(hang=0; hang<20; hang++){
    41. 		if(hang == 0){
    42. 			for(lie=0; lie<20; lie++){
    43. 				printw("--");
    44. 			}
    45. 			printw("\n");
    46. 		}
    47. 		
    48. 		if(hang>=0 && hang<=19) {
    49. 			for(lie=0; lie<=20; lie++){
    50. 				if(lie == 0 || lie == 20){
    51. 					printw("|");
    52. 				}else if(hasSnakeNode(hang,lie)){
    53. 					printw("[]");
    54. 				}else{
    55. 					printw("  ");
    56. 				}
    57. 			}
    58. 			printw("\n");
    59. 		}
    60.  
    61. 		if(hang == 19){
    62. 			for(lie=0; lie<20; lie++){
    63. 				printw("--");
    64. 			}
    65. 			printw("\n");
    66. 			printw("By ShiYaHao!\n");
    67. 		}
    68. 	}
    69. }
    70.  
    71. void addNode()
    72. {
    73. 	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));
    74. 	
    75. 	new->hang = tail->hang;
    76. 	new->lie  = tail->lie+1;
    77. 	new->next = NULL;
    78.  
    79. 	tail->next = new;
    80. 	tail = new;
    81. }
    82.  
    83. void initSnake()
    84. {
    85. 	head = (struct Snake *)malloc(sizeof(struct Snake));
    86. 	if(head == NULL){
    87. 		printw("malloc error\n");
    88. 	}
    89. 	head->hang = 2;
    90. 	head->lie = 2;
    91. 	head->next = NULL;
    92.  
    93. 	tail = head;
    94.  
    95. 	addNode();
    96. 	addNode();
    97. 	addNode();
    98. 	addNode();
    99. }
    100.  
    101. void deletNode()
    102. {
    103. 	struct Snake *p;
    104. 	p = head;
    105. 	
    106. 	head = head->next;
    107. 	free(p);
    108. }
    109.  
    110. void moveSnake()
    111. {
    112. 	addNode();		//增加一个节点
    113. 	deletNode();	//删除头节点
    114. }
    115.  
    116. int main()
    117. {
    118. 	int con;
    119.  
    120. 	initNcurse();
    121. 	initSnake();
    122.  
    123. 	gamPic();
    124. 	
    125. 	while(1){
    126. 		con = getch();			//con获取键值
    127. 		if(con == KEY_RIGHT){	//如果是右键
    128. 			moveSnake();		//向右移动
    129. 			gamPic();			//必须刷新一下界面，否则看不到🐍移动
    130. 		}		
    131. 	}
    132. 	getch();
    133. 	endwin();
    134. 	return 0;
    135.  }

    4.2 贪吃蛇撞墙重新开始： 

    1. #include 
    2. #include 
    3.  
    4. struct Snake
    5. {
    6. 	int hang;
    7. 	int lie;
    8. 	struct Snake *next;
    9. };
    10.  
    11. struct Snake *head = NULL;
    12. struct Snake *tail = NULL;
    13.  
    14. void initNcurse()
    15. {
    16. 	initscr();
    17. 	keypad(stdscr,1);
    18. }
    19.  
    20. int hasSnakeNode(int i, int j)
    21. {
    22. 	struct Snake *p = head;
    23.  
    24. 	while(p != NULL){
    25. 		if(p->hang == i && p->lie == j){
    26. 			return 1;
    27. 		}
    28. 		p = p->next;
    29. 	}
    30. 	return 0;
    31. }
    32.  
    33. void gamPic()
    34. {
    35. 	int hang;
    36. 	int lie;
    37. 	
    38. 	move(0,0);
    39. 		
    40. 	for(hang=0; hang<20; hang++){
    41. 		if(hang == 0){
    42. 			for(lie=0; lie<20; lie++){
    43. 				printw("--");
    44. 			}
    45. 			printw("\n");
    46. 		}
    47. 		
    48. 		if(hang>=0 && hang<=19) {
    49. 			for(lie=0; lie<=20; lie++){
    50. 				if(lie == 0 || lie == 20){
    51. 					printw("|");
    52. 				}else if(hasSnakeNode(hang,lie)){
    53. 					printw("[]");
    54. 				}else{
    55. 					printw("  ");
    56. 				}
    57. 			}
    58. 			printw("\n");
    59. 		}
    60.  
    61. 		if(hang == 19){
    62. 			for(lie=0; lie<20; lie++){
    63. 				printw("--");
    64. 			}
    65. 			printw("\n");
    66. 			printw("By ShiYaHao!\n");
    67. 		}
    68. 	}
    69. }
    70.  
    71. void addNode()
    72. {
    73. 	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));
    74. 	if(new == NULL){
    75. 		printw("malloc error\n");
    76. 	}
    77. 	new->hang = tail->hang;
    78. 	new->lie  = tail->lie+1;
    79. 	new->next = NULL;
    80.  
    81. 	tail->next = new;
    82. 	tail = new;
    83. }
    84.  
    85. void initSnake()
    86. {
    87. 	struct Snake *p;
    88. 	while(head != NULL){	判断蛇是否为空，清理内存 
    89. 		p = head;
    90. 		head = head->next;
    91. 		free(p);
    92. 	}
    93.  
    94. 	head = (struct Snake *)malloc(sizeof(struct Snake));
    95. 	if(head == NULL){
    96. 		printw("malloc error\n");
    97. 	}
    98. 	head->hang = 1;
    99. 	head->lie = 1;
    100. 	head->next = NULL;
    101.  
    102. 	tail = head;
    103.  
    104. 	addNode();
    105. 	addNode();
    106. 	addNode();
    107. 	addNode();
    108. }
    109.  
    110. void deletNode()
    111. {
    112. 	struct Snake *p;
    113. 	p = head;
    114. 	
    115. 	head = head->next;
    116. 	free(p);
    117. }
    118.  
    119. void moveSnake()
    120. {
    121. 	addNode();
    122. 	deletNode();
    123. 	
    124.     //判断蛇的尾巴碰到上下左右的四个边框后就重新开始
    125. 	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
    126. 		initSnake();
    127. 	}
    128. }
    129.  
    130. int main()
    131. {
    132. 	int con;
    133.  
    134. 	initNcurse();
    135. 	initSnake();
    136.  
    137. 	gamPic();
    138. 	
    139. 	while(1){
    140. 		con = getch();
    141. 		if(con == KEY_RIGHT){
    142. 			moveSnake();
    143. 			gamPic();
    144. 		}		
    145. 	}
    146. 	getch();
    147. 	endwin();
    148. 	return 0;
    149.  }

    4.3 贪吃蛇脱缰自由向右行走

    1. #include 
    2. #include 
    3.  
    4. struct Snake
    5. {
    6. 	int hang;
    7. 	int lie;
    8. 	struct Snake *next;
    9. };
    10.  
    11. struct Snake *head = NULL;
    12. struct Snake *tail = NULL;
    13.  
    14. void initNcurse()
    15. {
    16. 	initscr();
    17. 	keypad(stdscr,1);
    18. }
    19.  
    20. int hasSnakeNode(int i, int j)
    21. {
    22. 	struct Snake *p = head;
    23.  
    24. 	while(p != NULL){
    25. 		if(p->hang == i && p->lie == j){
    26. 			return 1;
    27. 		}
    28. 		p = p->next;
    29. 	}
    30. 	return 0;
    31. }
    32.  
    33. void gamPic()
    34. {
    35. 	int hang;
    36. 	int lie;
    37. 	
    38. 	move(0,0);
    39. 		
    40. 	for(hang=0; hang<20; hang++){
    41. 		if(hang == 0){
    42. 			for(lie=0; lie<20; lie++){
    43. 				printw("--");
    44. 			}
    45. 			printw("\n");
    46. 		}
    47. 		
    48. 		if(hang>=0 && hang<=19) {
    49. 			for(lie=0; lie<=20; lie++){
    50. 				if(lie == 0 || lie == 20){
    51. 					printw("|");
    52. 				}else if(hasSnakeNode(hang,lie)){
    53. 					printw("[]");
    54. 				}else{
    55. 					printw("  ");
    56. 				}
    57. 			}
    58. 			printw("\n");
    59. 		}
    60.  
    61. 		if(hang == 19){
    62. 			for(lie=0; lie<20; lie++){
    63. 				printw("--");
    64. 			}
    65. 			printw("\n");
    66. 			printw("By ShiYaHao!\n");
    67. 		}
    68. 	}
    69. }
    70.  
    71. void addNode()
    72. {
    73. 	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));
    74. 	if(new == NULL){
    75. 		printw("malloc error\n");
    76. 	}
    77. 	new->hang = tail->hang;
    78. 	new->lie  = tail->lie+1;
    79. 	new->next = NULL;
    80.  
    81. 	tail->next = new;
    82. 	tail = new;
    83. }
    84.  
    85. void initSnake()
    86. {
    87. 	struct Snake *p;
    88. 	while(head != NULL){
    89. 		p = head;
    90. 		head = head->next;
    91. 		free(p);
    92. 	}
    93.  
    94. 	head = (struct Snake *)malloc(sizeof(struct Snake));
    95. 	if(head == NULL){
    96. 		printw("malloc error\n");
    97. 	}
    98. 	head->hang = 1;
    99. 	head->lie = 1;
    100. 	head->next = NULL;
    101.  
    102. 	tail = head;
    103.  
    104. 	addNode();
    105. 	addNode();
    106. 	addNode();
    107. 	addNode();
    108. }
    109.  
    110. void deletNode()
    111. {
    112. 	struct Snake *p;
    113. 	p = head;
    114. 	
    115. 	head = head->next;
    116. 	free(p);
    117. }
    118.  
    119. void moveSnake()
    120. {
    121. 	addNode();
    122. 	deletNode();
    123.  
    124. 	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
    125. 		initSnake();
    126. 	}
    127. }
    128.  
    129. int main()
    130. {
    131. 	int con;
    132.  
    133. 	initNcurse();
    134. 	initSnake();
    135.  
    136. 	gamPic();
    137. 	
    138. 	while(1){	//之前受方向键控制，现在自由行走
    139. 			moveSnake();	
    140. 			gamPic();	
    141. 			refresh();			//刷新界面
    142. 			usleep(100000);		//延时100ms
    143. 	}
    144. 	getch();
    145. 	endwin();
    146. 	return 0;
    147.  }

    五、Linux线程引入

    5.1 贪吃蛇方向移动和刷新界面一起实现面临的问题：

    1. #include 
    2. #include 
    3.  
    4. struct Snake
    5. {
    6. 	int hang;
    7. 	int lie;
    8. 	struct Snake *next;
    9. };
    10.  
    11. struct Snake *head = NULL;
    12. struct Snake *tail = NULL;
    13.  
    14. void initNcurse()
    15. {
    16. 	initscr();
    17. 	keypad(stdscr,1);
    18. }
    19.  
    20. int hasSnakeNode(int i, int j)
    21. {
    22. 	struct Snake *p = head;
    23.  
    24. 	while(p != NULL){
    25. 		if(p->hang == i && p->lie == j){
    26. 			return 1;
    27. 		}
    28. 		p = p->next;
    29. 	}
    30. 	return 0;
    31. }
    32.  
    33. void gamPic()
    34. {
    35. 	int hang;
    36. 	int lie;
    37. 	
    38. 	move(0,0);
    39. 		
    40. 	for(hang=0; hang<20; hang++){
    41. 		if(hang == 0){
    42. 			for(lie=0; lie<20; lie++){
    43. 				printw("--");
    44. 			}
    45. 			printw("\n");
    46. 		}
    47. 		
    48. 		if(hang>=0 && hang<=19) {
    49. 			for(lie=0; lie<=20; lie++){
    50. 				if(lie == 0 || lie == 20){
    51. 					printw("|");
    52. 				}else if(hasSnakeNode(hang,lie)){
    53. 					printw("[]");
    54. 				}else{
    55. 					printw("  ");
    56. 				}
    57. 			}
    58. 			printw("\n");
    59. 		}
    60.  
    61. 		if(hang == 19){
    62. 			for(lie=0; lie<20; lie++){
    63. 				printw("--");
    64. 			}
    65. 			printw("\n");
    66. 			printw("By ShiYaHao!\n");
    67. 		}
    68. 	}
    69. }
    70.  
    71. void addNode()
    72. {
    73. 	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));
    74. 	if(new == NULL){
    75. 		printw("malloc error\n");
    76. 	}
    77. 	new->hang = tail->hang;
    78. 	new->lie  = tail->lie+1;
    79. 	new->next = NULL;
    80.  
    81. 	tail->next = new;
    82. 	tail = new;
    83. }
    84.  
    85. void initSnake()
    86. {
    87. 	struct Snake *p;
    88. 	while(head != NULL){
    89. 		p = head;
    90. 		head = head->next;
    91. 		free(p);
    92. 	}
    93.  
    94. 	head = (struct Snake *)malloc(sizeof(struct Snake));
    95. 	if(head == NULL){
    96. 		printw("malloc error\n");
    97. 	}
    98. 	head->hang = 1;
    99. 	head->lie = 1;
    100. 	head->next = NULL;
    101.  
    102. 	tail = head;
    103.  
    104. 	addNode();
    105. 	addNode();
    106. 	addNode();
    107. 	addNode();
    108. }
    109.  
    110. void deletNode()
    111. {
    112. 	struct Snake *p;
    113. 	p = head;
    114. 	
    115. 	head = head->next;
    116. 	free(p);
    117. }
    118.  
    119. void moveSnake()
    120. {
    121. 	addNode();
    122. 	deletNode();
    123.  
    124. 	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
    125. 		initSnake();
    126. 	}
    127. }
    128.  
    129. int main()
    130. {
    131. 	int key;
    132.  
    133. 	initNcurse();
    134. 	initSnake();
    135.  
    136. 	gamPic();
    137. 	
    138. 	while(1){
    139. 			moveSnake();
    140. 			gamPic();
    141. 			refresh();
    142. 			usleep(100000);
    143. 	}
    144. 	while(1){
    145. 		
    146. 		key = getch();
    147. 		switch(key){
    148. 			case KEY_DOWN:
    149. 				printw("DOWN\n");
    150. 				break;	
    151. 			case KEY_UP:
    152. 				printw("UP\n");
    153. 				break;
    154. 			case KEY_LEFT:
    155. 				printw("LEFT\n");
    156. 				break;
    157. 			case KEY_RIGHT:
    158. 				printw("RIGHT\n");
    159. 				break;
    160. 		}
    161. 	}	
    162. 	getch();
    163. 	endwin();
    164. 	return 0;
    165.  }

    • 在上面的程序中main函数中有两个while(1)循环,这样就会出现问题，程序运行的现象是：获取按键值的这个while循环根本不会执行，那该如何解决？于是引入“Linux线程”！

    • 在贪吃蛇运动过程中，我们需要改变蛇的移动方向，这是就需要不停扫描键盘输入的值来判断方向，同时还需要不停的刷新界面，为了多个while循环并存这里需要引入linux线程。

    5.2 线程的基本用法：

    1. #include   // 头文件
    2.  
    3. pthread_t：当前Linux中可理解为：typedef  unsigned long int  pthread_t;
    4. 如：pthread_t t1;  //多线程定义
    5.  
    6. pthread_create(&t1,NULL,refreshInterface,NULL); 
    7. 参数1：传出参数，保存系统为我们分配好的线程ID
    8. 参数2：通常传NULL，表示使用线程默认属性。若想使用具体属性也可以修改该参数。
    9. 参数3：函数指针，指向线程主函数(线程体)，该函数运行结束，则线程结束。
    10. 参数4：线程主函数执行期间所使用的参数，如要传多个参数, 可以用结构封装。
    11.  
    12. 使用多线程的函数必须返回指针型，如void *refreshInterface()
    13.  
    14. 注：gcc xxx.c -lcurses -lpthead  //编译需要连接pthead库

    5.3 线程demo案例：

    1. /*
    2. 	在这个程序当中只有func1一个函数会被执行,func2函数根本不会执行
    3. 	想要解决这个问题就需要引入Linux的线程
    4. */
    5. #include 
    6.  
    7. void pfunc1()
    8. {
    9.     while(1){
    10.          printf("this is a pfunc1\n");
    11.        	 sleep(1);
    12.     } 
    13. }
    14.  
    15. void pfunc2()
    16. {
    17.     while(1){
    18.          printf("this is a pfunc2\n");
    19.        	 sleep(1);
    20.     } 
    21. }
    22.  
    23. int main()
    24. {
    25.     pfunc1();
    26.     pfunc2();
    27.     return 0;
    28. }
    1. /*
    2. 	引入Linux线程修改代码，func1和func2两个函数都可以执行
    3. */
    4. #include 
    5. #include 	//线程头文件
    6.  
    7. void* func1()
    8. {
    9. 	while(1){
    10.  
    11. 		printf("this is a func1\n");
    12. 		sleep(1);
    13. 	}
    14. 	
    15. }
    16.  
    17. void* func2()
    18. {
    19. 	while(1){
    20.  
    21. 		printf("this is a func2\n");
    22. 		sleep(1);
    23. 	}
    24. }
    25.  
    26. int main()
    27. {
    28. 	pthread_t th1;	//定义一个th1线程
    29. 	pthread_t th2;	//定义一个th2线程
    30.  
    31. 	pthread_create(&th1, NULL, func1, NULL);
    32. 	pthread_create(&th2, NULL, func2, NULL);
    33. 	while(1);
    34. 	return 0;
    35. }

    5.4 使用线程解决贪吃蛇方向移动和刷新界面一起实现面临的问题：

    1. #include 
    2. #include 
    3.  
    4. struct Snake
    5. {
    6. 	int hang;
    7. 	int lie;
    8. 	struct Snake *next;
    9. };
    10.  
    11. struct Snake *head = NULL;
    12. struct Snake *tail = NULL;
    13.  
    14. int key;
    15.  
    16. void initNcurse()
    17. {
    18. 	initscr();
    19. 	keypad(stdscr,1);
    20. }
    21.  
    22. int hasSnakeNode(int i, int j)
    23. {
    24. 	struct Snake *p = head;
    25.  
    26. 	while(p != NULL){
    27. 		if(p->hang == i && p->lie == j){
    28. 			return 1;
    29. 		}
    30. 		p = p->next;
    31. 	}
    32. 	return 0;
    33. }
    34.  
    35. void gamPic()
    36. {
    37. 	int hang;
    38. 	int lie;
    39. 	
    40. 	move(0,0);
    41. 		
    42. 	for(hang=0; hang<20; hang++){
    43. 		if(hang == 0){
    44. 			for(lie=0; lie<20; lie++){
    45. 				printw("--");
    46. 			}
    47. 			printw("\n");
    48. 		}
    49. 		
    50. 		if(hang>=0 && hang<=19) {
    51. 			for(lie=0; lie<=20; lie++){
    52. 				if(lie == 0 || lie == 20){
    53. 					printw("|");
    54. 				}else if(hasSnakeNode(hang,lie)){
    55. 					printw("[]");
    56. 				}else{
    57. 					printw("  ");
    58. 				}
    59. 			}
    60. 			printw("\n");
    61. 		}
    62.  
    63. 		if(hang == 19){
    64. 			for(lie=0; lie<20; lie++){
    65. 				printw("--");
    66. 			}
    67. 			printw("\n");
    68. 			printw("By ShiYaHao!key = %d\n",key);
    69. 		}
    70. 	}
    71. }
    72.  
    73. void addNode()
    74. {
    75. 	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));
    76.  
    77. 	new->hang = tail->hang;
    78. 	new->lie  = tail->lie+1;
    79. 	new->next = NULL;
    80.  
    81. 	tail->next = new;
    82. 	tail = new;
    83. }
    84.  
    85. void initSnake()
    86. {
    87. 	struct Snake *p;
    88. 	while(head != NULL){
    89. 		p = head;
    90. 		head = head->next;
    91. 		free(p);
    92. 	}
    93.  
    94. 	head = (struct Snake *)malloc(sizeof(struct Snake));
    95.  
    96. 	head->hang = 1;
    97. 	head->lie = 1;
    98. 	head->next = NULL;
    99.  
    100. 	tail = head;
    101.  
    102. 	addNode();
    103. 	addNode();
    104. 	addNode();
    105. 	addNode();
    106. }
    107.  
    108. void deletNode()
    109. {
    110. 	struct Snake *p;
    111. 	p = head;
    112. 	
    113. 	head = head->next;
    114. 	free(p);
    115. }
    116.  
    117. void moveSnake()
    118. {
    119. 	addNode();
    120. 	deletNode();
    121.  
    122. 	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
    123. 		initSnake();
    124. 	}
    125. }
    126.  
    127. void* refreshJieMian()
    128. {
    129. 	
    130. 	while(1){
    131. 			moveSnake();
    132. 			gamPic();
    133. 			refresh();
    134. 			usleep(100000);
    135. 	}
    136. }
    137.  
    138. void* changeDir()
    139. {
    140. 	
    141. 	while(1){
    142. 		
    143. 		key = getch();
    144. 		switch(key){
    145. 			case KEY_DOWN:
    146. 				printw("DOWN\n");
    147. 				break;	
    148. 			case KEY_UP:
    149. 				printw("UP\n");
    150. 				break;
    151. 			case KEY_LEFT:
    152. 				printw("LEFT\n");
    153. 				break;
    154. 			case KEY_RIGHT:
    155. 				printw("RIGHT\n");
    156. 				break;
    157. 		}
    158. 	}	
    159. }
    160.  
    161. int main()
    162. {
    163. 	initNcurse();
    164. 	initSnake();
    165. 	
    166.     //注意：线程创建要放在初始化后面，不然就会导致程序段错误(答疑老师解决)
    167. 	pthread_t t1;
    168. 	pthread_t t2;
    169. 	pthread_create(&t1, NULL, refreshJieMian, NULL);
    170. 	pthread_create(&t2, NULL, changeDir, NULL);
    171.  
    172. 	gamPic();
    173. 	
    174. 	while(1);
    175. 	getch();
    176. 	endwin();
    177. 	return 0;
    178.  }

    • 蛇在向右移动的同时也可以按方向键，这就是引入线程之后的牛逼之处！

    六、贪吃蛇跑起来

    6.1 实现贪吃蛇四方向的风骚走位：
    1. #include 
    2. #include 
    3. #include 
    4.  
    5. #define UP    1
    6. #define DOWN  2
    7. #define LEFT  3
    8. #define RIGHT 4
    9.  
    10. struct Snake
    11. {
    12. 	int hang;
    13. 	int lie;
    14. 	struct Snake *next;
    15. };
    16.  
    17. struct Snake *head = NULL;
    18. struct Snake *tail = NULL;
    19.  
    20. int key;
    21. int dir;
    22.  
    23. void initNcurse()
    24. {
    25. 	initscr();
    26. 	keypad(stdscr,1);
    27. }
    28.  
    29. int hasSnakeNode(int i, int j)
    30. {
    31. 	struct Snake *p = head;
    32.  
    33. 	while(p != NULL){
    34. 		if(p->hang == i && p->lie == j){
    35. 			return 1;
    36. 		}
    37. 		p = p->next;
    38. 	}
    39. 	return 0;
    40. }
    41.  
    42. void gamPic()
    43. {
    44. 	int hang;
    45. 	int lie;
    46. 	
    47. 	move(0,0);
    48. 		
    49. 	for(hang=0; hang<20; hang++){
    50. 		if(hang == 0){
    51. 			for(lie=0; lie<20; lie++){
    52. 				printw("--");
    53. 			}
    54. 			printw("\n");
    55. 		}
    56. 		
    57. 		if(hang>=0 && hang<=19) {
    58. 			for(lie=0; lie<=20; lie++){
    59. 				if(lie == 0 || lie == 20){
    60. 					printw("|");
    61. 				}else if(hasSnakeNode(hang,lie)){
    62. 					printw("[]");：
    63. 				}else{
    64. 					printw("  ");
    65. 				}
    66. 			}
    67. 			printw("\n");
    68. 		}
    69.  
    70. 		if(hang == 19){
    71. 			for(lie=0; lie<20; lie++){
    72. 				printw("--");
    73. 			}
    74. 			printw("\n");
    75. 			printw("By ShiYaHao!key = %d\n",key);
    76. 		}
    77. 	}
    78. }
    79.  
    80. void addNode()
    81. {
    82. 	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));
    83.  
    84. 	new->hang = tail->hang;
    85. 	new->lie  = tail->lie+1;
    86. 	new->next = NULL;
    87.  
    88. 	switch(dir){
    89. 		case UP:	
    90.       		new->hang = tail->hang-1;
    91. 			new->lie  = tail->lie;
    92. 			break;
    93. 		case DOWN:	
    94.       		new->hang = tail->hang+1;
    95. 			new->lie  = tail->lie;
    96. 			break;
    97. 		case LEFT:	
    98.       		new->hang = tail->hang;
    99. 			new->lie  = tail->lie-1;
    100. 			break;
    101. 		case RIGHT:	
    102.       		new->hang = tail->hang;
    103. 			new->lie  = tail->lie+1;
    104. 			break;
    105. 	}
    106.  
    107. 	tail->next = new;
    108. 	tail = new;
    109. }
    110.  
    111. void initSnake()
    112. {
    113. 	struct Snake *p;
    114.  
    115. 	dir = RIGHT;
    116. 	
    117. 	while(head != NULL){
    118. 		p = head;
    119. 		head = head->next;
    120. 		free(p);
    121. 	}
    122.  
    123. 	head = (struct Snake *)malloc(sizeof(struct Snake));
    124.  
    125. 	head->hang = 1;
    126. 	head->lie = 1;
    127. 	head->next = NULL;
    128.  
    129. 	tail = head;
    130.  
    131. 	addNode();
    132. 	addNode();
    133. 	addNode();
    134. 	addNode();
    135. }
    136.  
    137. void deletNode()
    138. {
    139. 	struct Snake *p;
    140. 	p = head;
    141. 	
    142. 	head = head->next;
    143. 	free(p);
    144. }
    145.  
    146. void moveSnake()
    147. {
    148. 	addNode();
    149. 	deletNode();
    150.  
    151. 	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
    152. 		initSnake();
    153. 	}
    154. }
    155.  
    156. void* refreshJieMian()
    157. {
    158. 	
    159. 	while(1){
    160. 			moveSnake();
    161. 			gamPic();
    162. 			refresh();
    163. 			usleep(100000);
    164. 	}
    165. }
    166.  
    167. void* changeDir()
    168. {
    169. 	
    170. 	while(1){
    171. 		
    172. 		key = getch();
    173. 		switch(key){
    174. 			case KEY_DOWN:
    175. 				dir = DOWN;
    176. 				break;	
    177. 			case KEY_UP:
    178. 				dir = UP;
    179. 				break;
    180. 			case KEY_LEFT:
    181. 				dir = LEFT;
    182. 				break;
    183. 			case KEY_RIGHT:
    184. 				dir = RIGHT;
    185. 				break;
    186. 		}
    187. 	}	
    188. }
    189.  
    190. int main()
    191. {
    192. 	pthread_t t1;
    193. 	pthread_t t2;
    194.  
    195. 	initNcurse();
    196. 	initSnake();
    197.  
    198. 	gamPic();
    199.  
    200. 	pthread_create(&t1, NULL, refreshJieMian, NULL);
    201. 	pthread_create(&t2, NULL, changeDir, NULL);
    202.  
    203. 	
    204. 	while(1);
    205. 	getch();
    206. 	endwin();
    207. 	return 0;
    208.  }

    6.2 用绝对值方式来解决不合理的走位：

    1. #include 
    2. #include 
    3.  
    4. #define UP     1
    5. #define DOWN  -1
    6. #define LEFT   2
    7. #define RIGHT -2
    8.  
    9. struct Snake
    10. {
    11. 	int hang;
    12. 	int lie;
    13. 	struct Snake *next;
    14. };
    15.  
    16. struct Snake *head = NULL;
    17. struct Snake *tail = NULL;
    18.  
    19. int key;
    20. int dir;
    21.  
    22. void initNcurse()
    23. {
    24. 	initscr();
    25. 	keypad(stdscr,1);
    26. 	noecho();
    27. }
    28.  
    29. int hasSnakeNode(int i, int j)
    30. {
    31. 	struct Snake *p = head;
    32.  
    33. 	while(p != NULL){
    34. 		if(p->hang == i && p->lie == j){
    35. 			return 1;
    36. 		}
    37. 		p = p->next;
    38. 	}
    39. 	return 0;
    40. }
    41.  
    42. void gamPic()
    43. {
    44. 	int hang;
    45. 	int lie;
    46. 	
    47. 	move(0,0);
    48. 		
    49. 	for(hang=0; hang<20; hang++){
    50. 		if(hang == 0){
    51. 			for(lie=0; lie<20; lie++){
    52. 				printw("--");
    53. 			}
    54. 			printw("\n");
    55. 		}
    56. 		
    57. 		if(hang>=0 && hang<=19) {
    58. 			for(lie=0; lie<=20; lie++){
    59. 				if(lie == 0 || lie == 20){
    60. 					printw("|");
    61. 				}else if(hasSnakeNode(hang,lie)){
    62. 					printw("[]");
    63. 				}else{
    64. 					printw("  ");
    65. 				}
    66. 			}
    67. 			printw("\n");
    68. 		}
    69.  
    70. 		if(hang == 19){
    71. 			for(lie=0; lie<20; lie++){
    72. 				printw("--");
    73. 			}
    74. 			printw("\n");
    75. 			printw("By ShiYaHao!key = %d\n",key);
    76. 		}
    77. 	}
    78. }
    79.  
    80. void addNode()
    81. {
    82. 	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));
    83.  
    84. 	new->hang = tail->hang;
    85. 	new->lie  = tail->lie+1;
    86. 	new->next = NULL;
    87.  
    88. 	switch(dir){
    89. 		case UP:	
    90.       			new->hang = tail->hang-1;
    91. 			new->lie  = tail->lie;
    92. 			break;
    93. 		case DOWN:	
    94.       			new->hang = tail->hang+1;
    95. 			new->lie  = tail->lie;
    96. 			break;
    97. 		case LEFT:	
    98.       			new->hang = tail->hang;
    99. 			new->lie  = tail->lie-1;
    100. 			break;
    101. 		case RIGHT:	
    102.       			new->hang = tail->hang;
    103. 			new->lie  = tail->lie+1;
    104. 			break;
    105. 	}
    106.  
    107. 	tail->next = new;
    108. 	tail = new;
    109. }
    110.  
    111. void initSnake()
    112. {
    113. 	struct Snake *p;
    114.  
    115. 	dir = RIGHT;
    116. 	
    117. 	while(head != NULL){
    118. 		p = head;
    119. 		head = head->next;
    120. 		free(p);
    121. 	}
    122.  
    123. 	head = (struct Snake *)malloc(sizeof(struct Snake));
    124.  
    125. 	head->hang = 1;
    126. 	head->lie = 1;
    127. 	head->next = NULL;
    128.  
    129. 	tail = head;
    130.  
    131. 	addNode();
    132. 	addNode();
    133. 	addNode();
    134. 	addNode();
    135. }
    136.  
    137. void deletNode()
    138. {
    139. 	struct Snake *p;
    140. 	p = head;
    141. 	
    142. 	head = head->next;
    143. 	free(p);
    144. }
    145.  
    146. void moveSnake()
    147. {
    148. 	addNode();
    149. 	deletNode();
    150.  
    151. 	if(tail->hang == 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
    152. 		initSnake();
    153. 	}
    154. }
    155.  
    156. void refreshJieMian()
    157. {
    158. 	
    159. 	while(1){
    160. 			moveSnake();
    161. 			gamPic();
    162. 			refresh();
    163. 			usleep(100000);
    164. 	}
    165. }
    166.  
    167. void turn(int direction)			通过绝对值判断相反方向不触发
    168. {
    169. 	if(abs(dir) != abs(direction)){
    170. 		dir = direction;
    171. 	}
    172. }
    173.  
    174. void changeDir()
    175. {
    176. 	
    177. 	while(1){
    178. 		
    179. 		key = getch();
    180. 		switch(key){
    181. 			case KEY_DOWN:
    182. 				turn(DOWN);
    183. 				break;	
    184. 			case KEY_UP:
    185. 				turn(UP);
    186. 				break;
    187. 			case KEY_LEFT:
    188. 				turn(LEFT);
    189. 				break;
    190. 			case KEY_RIGHT:
    191. 				turn(RIGHT);
    192. 				break;
    193. 		}
    194. 	}	
    195. }
    196.  
    197. int main()
    198. {
    199. 	pthread_t t1;
    200. 	pthread_t t2;
    201.  
    202. 	initNcurse();
    203. 	initSnake();
    204.  
    205. 	gamPic();
    206.  
    207. 	pthread_create(&t1, NULL, refreshJieMian, NULL);
    208. 	pthread_create(&t2, NULL, changeDir, NULL);
    209.  
    210. 	
    211. 	while(1);
    212. 	getch();
    213. 	endwin();
    214. 	return 0;
    215.  }

    6.3 贪吃蛇吃饭了（食物的位置是随机的）：

    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. struct Snake
    11. {
    12. 	int hang;
    13. 	int lie;
    14. 	struct Snake *next;
    15. };
    16.  
    17. struct Snake *head = NULL;
    18. struct Snake *tail = NULL;
    19.  
    20. int key;
    21. int dir;
    22.  
    23. struct Snake food;
    24.  
    25. void initFood()
    26. {
    27. 	int x = rand()%20;
    28. 	int y = rand()%20;
    29.  
    30. 	food.hang = x;
    31. 	food.lie  = y;
    32. }
    33.  
    34. void initNcurse()
    35. {
    36. 	initscr();
    37. 	keypad(stdscr,1);
    38. 	noecho();
    39. }
    40.  
    41. int hasSnakeNode(int i, int j)
    42. {
    43. 	struct Snake *p = head;
    44.  
    45. 	while(p != NULL){
    46. 		if(p->hang == i && p->lie == j){
    47. 			return 1;
    48. 		}
    49. 		p = p->next;
    50. 	}
    51. 	return 0;
    52. }
    53.  
    54. int hasFood(int i, int j)
    55. {
    56. 	if(food.hang == i && food.lie == j){
    57. 		return 1;
    58. 	}
    59. 	return 0;
    60. }
    61.  
    62. void gamPic()
    63. {
    64. 	int hang;
    65. 	int lie;
    66. 	
    67. 	move(0,0);
    68. 		
    69. 	for(hang=0; hang<20; hang++){
    70. 		if(hang == 0){
    71. 			for(lie=0; lie<20; lie++){
    72. 				printw("--");
    73. 			}
    74. 			printw("\n");
    75. 		}
    76. 		
    77. 		if(hang>=0 && hang<=19) {
    78. 			for(lie=0; lie<=20; lie++){
    79. 				if(lie == 0 || lie == 20){
    80. 					printw("|");
    81. 				}else if(hasSnakeNode(hang,lie)){
    82. 					printw("[]");
    83. 				}else if(hasFood(hang,lie)){
    84. 					printw("##");
    85. 				}else{
    86. 					printw("  ");
    87. 				}
    88. 			}
    89. 			printw("\n");
    90. 		}
    91.  
    92. 		if(hang == 19){
    93. 			for(lie=0; lie<20; lie++){
    94. 				printw("--");
    95. 			}
    96. 			printw("\n");
    97. 			printw("By ShiYaHao! food.hang = %d,food.lie = %d\n",food.hang,food.lie);
    98. 		}
    99. 	}
    100. }
    101.  
    102. void addNode()
    103. {
    104. 	struct Snake *new =(struct Snake *) malloc(sizeof(struct Snake));
    105.  
    106. 	new->hang = tail->hang;
    107. 	new->lie  = tail->lie+1;
    108. 	new->next = NULL;
    109.  
    110. 	switch(dir){
    111. 		case UP:	
    112.       			new->hang = tail->hang-1;
    113. 			new->lie  = tail->lie;
    114. 			break;
    115. 		case DOWN:	
    116.       			new->hang = tail->hang+1;
    117. 			new->lie  = tail->lie;
    118. 			break;
    119. 		case LEFT:	
    120.       			new->hang = tail->hang;
    121. 			new->lie  = tail->lie-1;
    122. 			break;
    123. 		case RIGHT:	
    124.       			new->hang = tail->hang;
    125. 			new->lie  = tail->lie+1;
    126. 			break;
    127. 	}
    128.  
    129. 	tail->next = new;
    130. 	tail = new;
    131. }
    132.  
    133. void initSnake()
    134. {
    135. 	struct Snake *p;
    136.  
    137. 	dir = RIGHT;
    138. 	
    139. 	while(head != NULL){
    140. 		p = head;
    141. 		head = head->next;
    142. 		free(p);
    143. 	}
    144. 	initFood();
    145. 	head = (struct Snake *)malloc(sizeof(struct Snake));
    146.  
    147. 	head->hang = 1;
    148. 	head->lie = 1;
    149. 	head->next = NULL;
    150.  
    151. 	tail = head;
    152.  
    153. 	addNode();
    154. 	addNode();
    155. 	addNode();
    156. 	addNode();
    157. }
    158.  
    159. void deletNode()
    160. {
    161. 	struct Snake *p;
    162. 	p = head;
    163. 	
    164. 	head = head->next;
    165. 	free(p);
    166. }
    167.  
    168. void moveSnake()
    169. {
    170. 	addNode();
    171. 	if(hasFood(tail->hang,tail->lie)){
    172. 		initFood();
    173. 	}else{	
    174. 		deletNode();
    175. 	}
    176.  
    177. 	if(tail->hang < 0 || tail->lie == 0 || tail->hang == 20 || tail->lie == 20){
    178. 		initSnake();
    179. 	}
    180. }
    181.  
    182. void* refreshJieMian()
    183. {
    184. 	
    185. 	while(1){
    186. 			moveSnake();
    187. 			gamPic();
    188. 			refresh();
    189. 			usleep(100000);
    190. 	}
    191. }
    192.  
    193. void turn(int direction)
    194. {
    195. 	if(abs(dir) != abs(direction)){
    196. 		dir = direction;
    197. 	}
    198. }
    199.  
    200. void* changeDir()
    201. {
    202. 	
    203. 	while(1){
    204. 		
    205. 		key = getch();
    206. 		switch(key){
    207. 			case KEY_DOWN:
    208. 				turn(DOWN);
    209. 				break;	
    210. 			case KEY_UP:
    211. 				turn(UP);
    212. 				break;
    213. 			case KEY_LEFT:
    214. 				turn(LEFT);
    215. 				break;
    216. 			case KEY_RIGHT:
    217. 				turn(RIGHT);
    218. 				break;
    219. 		}
    220. 	}	
    221. }
    222.  
    223. int main()
    224. {
    225. 	pthread_t t1;
    226. 	pthread_t t2;
    227.  
    228. 	initNcurse();
    229. 	initSnake();
    230.  
    231. 	gamPic();
    232.  
    233. 	pthread_create(&t1, NULL, refreshJieMian, NULL);
    234. 	pthread_create(&t2, NULL, changeDir, NULL);
    235.  
    236. 	
    237. 	while(1);
    238. 	getch();
    239. 	endwin();
    240. 	return 0;
    241.  }

    七、项目代码

    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. struct Snake{
    11. 	int hang;
    12. 	int lie;
    13. 	struct Snake *next;
    14. };
    15.  
    16. struct Snake *head = NULL;
    17. struct Snake *tail = NULL;
    18. struct Snake food;
    19. int key;
    20. int dir;
    21.  
    22. void addNode();                   /*从尾部插入新节点*/
    23.  
    24. //void initNcurses();               /*ncurses库的初始化函数*/
    25. //void gameMap();                   /*贪吃蛇地图的初始化*/
    26. //int printSnakeNode(int i,int j);  /*在地图上打印贪吃蛇的节点*/
    27. //void initSnake();                 /*初始化贪吃蛇*/
    28.  
    29. //void deletNode();                 /*删除头结点*/
    30. //void moveSnake();                 /*实现贪吃蛇的移动*/
    31. //void *refreshScreen();            /*线程实现图像刷新*/
    32. //void *changeDir();                /*线程实现贪吃蛇方向的改变*/
    33. //void turn(int direction);         /*防止出现不合理走位*/
    34. //void creatFood();                 /*随机出现食物*/
    35. //int hasFood(int i,int j);         /*打印食物*/
    36. //int ifSnakeDie();                 /*判断贪吃蛇是否死亡*/
    37.  
    38.  
    39. /*随机出现食物*/
    40. void creatFood()
    41. {
    42. 	int x = rand()%20;
    43. 	int y = rand()%19+1;
    44.  
    45. 	food.hang = x;
    46. 	food.lie = y;
    47. }
    48.  
    49. int hasFood(int i,int j)
    50. {
    51. 	if(food.hang == i && food.lie == j){
    52. 		return 1;
    53. 	}
    54. 	return 0;
    55. }
    56.  
    57. /*ncurses库的初始化函数*/
    58. void initNcurses()
    59. {
    60. 	initscr();//ncurse界面的初始化函数
    61. 	keypad(stdscr,1);//使用keypad函数，才可以使用键盘功能键
    62. 	noecho();//防止打印无关键值
    63. }
    64.  
    65. /*贪吃蛇地图的初始化*/
    66. void gameMap()
    67. {
    68. 	int hang;
    69. 	int lie;
    70.  
    71. 	move(0,0);//把光标的位置移到头，实现地图刷新时的覆盖
    72. 	for(hang=0;hang<20;hang++){
    73. 		if(hang == 0){
    74. 			for(lie=0;lie<20;lie++){
    75. 				printw("--");
    76. 			}
    77. 			printw("\n");
    78. 		}
    79. 		if(hang>=0 && hang<=19){
    80. 			for(lie=0;lie<=20;lie++){
    81. 				if(lie == 0 || lie == 20){
    82. 					printw("|");
    83. 				}else if(printSnakeNode(hang,lie)){
    84. 					printw("[]");
    85. 				}else if(hasFood(hang,lie)){
    86. 					printw("##");
    87. 				}else{
    88. 					printw("  ");
    89. 				}
    90. 			}
    91. 			printw("\n");
    92. 		}
    93. 		if(hang == 19){
    94. 			for(lie=0;lie<20;lie++){
    95. 				printw("--");
    96. 			}
    97. 			printw("\n");
    98. 		}
    99. 	}
    100. 		printw("By ShiYaHao!,food.hang = %d,food.lie = %d\n",food.hang,food.lie);
    101. }
    102.  
    103. /*在地图上打印贪吃蛇的节点*/
    104. int printSnakeNode(int i,int j)
    105. {
    106. 	struct Snake *p = head;
    107. 	while(p != NULL){
    108. 		if(p->hang == i && p->lie == j){
    109. 			return 1;
    110. 		}
    111. 		p = p->next;
    112. 	}
    113. 	return 0;
    114. }
    115.  
    116. /*初始化贪吃蛇*/
    117. void initSnake()
    118. {	
    119. 	struct Snake *p = NULL;
    120. 	if(head != NULL){   //当贪吃蛇死亡后，把多余节点释放
    121. 		p = head;
    122. 		head = head->next;	
    123. 		free(p);
    124. 	}
    125. 	
    126. 	creatFood();
    127. 	dir = RIGHT;
    128.  
    129. 	head = (struct Snake *)malloc(sizeof(struct Snake));
    130. 	head->hang = 1;
    131. 	head->lie = 1;
    132. 	head->next = NULL;
    133.  
    134. 	tail = head;
    135. 	
    136. 	addNode();
    137. 	addNode();
    138. 	addNode();
    139. }
    140.  
    141. /*从尾部插入新节点*/
    142. void addNode()
    143. {
    144. 	struct Snake *new = (struct Snake *)malloc(sizeof(struct Snake));
    145.  
    146. 	switch(dir){
    147. 		case UP:
    148. 			new->hang = tail->hang-1;
    149. 			new->lie = tail->lie;
    150. 			break;
    151. 		case DOWN:
    152. 			new->hang = tail->hang+1;
    153. 			new->lie = tail->lie;
    154. 			break;
    155. 		case LEFT:
    156. 			new->hang = tail->hang;
    157. 			new->lie = tail->lie-1;
    158. 			break;
    159. 		case RIGHT:
    160. 			new->hang = tail->hang;
    161. 			new->lie = tail->lie+1;
    162. 			break;
    163. 	}
    164. 	new->next = NULL;
    165. 	tail->next = new;
    166. 	tail = new;
    167.  
    168. }
    169.  
    170. /*删除头结点*/
    171. void deletNode()
    172. {
    173. 	struct Snake *p = head;
    174. 	head = head->next;
    175. 	free(p);	
    176. }
    177.  
    178. /*判断贪吃蛇是否死亡*/
    179. int ifSnakeDie()
    180. {
    181. 	struct Snake *p;
    182. 	p = head;
    183. 	if(tail->hang < 0 || tail->hang == 20 || tail->lie == 0 || tail->lie == 20){
    184. 		return 1;
    185. 	}
    186.  
    187. 	while(p->next != NULL){
    188. 		if(p->hang == tail->hang && p->lie == tail->lie){
    189. 			return 1;
    190. 		}
    191. 		p = p->next;
    192. 	}
    193. 	return 0;
    194.  
    195. }
    196.  
    197. /*实现贪吃蛇的移动*/
    198. void moveSnake()
    199. {
    200. 	addNode();
    201. 	if(hasFood(tail->hang,tail->lie)){
    202. 		creatFood();
    203. 	}else{
    204. 		deletNode();
    205. 	}
    206.  
    207. 	if(ifSnakeDie()){
    208. 		initSnake();
    209. 	}
    210.  
    211. }
    212.  
    213. /*线程实现图像刷新*/
    214. void *refreshScreen()
    215. {
    216. 	usleep(100000);
    217. 	while(1){
    218. 		moveSnake();
    219. 		gameMap();//刷新地图	
    220. 		refresh();//界面刷新函数
    221. 		usleep(100000);
    222. 	}
    223. }
    224. /*防止不合理走位*/
    225. void turn(int direction)
    226. {
    227. 	if(abs(dir) != abs(direction)){
    228. 		dir = direction;
    229. 	}
    230. }
    231.  
    232. /*线程实现贪吃蛇方向的改变*/
    233. void *changeDir()
    234. {
    235. 	while(1){
    236. 		key = getch();
    237. 		switch(key){
    238. 			case KEY_UP:
    239. 				turn(UP);
    240. 				break;
    241. 			case KEY_DOWN:
    242. 				turn(DOWN);
    243. 				break;
    244. 			case KEY_LEFT:
    245. 				turn(LEFT);
    246. 				break;
    247. 			case KEY_RIGHT:
    248. 				turn(RIGHT);
    249. 				break;
    250. 		}
    251. 	}
    252. }
    253.  
    254. int main()
    255. {
    256. 	pthread_t t1;
    257. 	pthread_t t2;
    258.  
    259. 	initNcurses();
    260. 	initSnake();
    261. 	gameMap();
    262.  
    263. 	pthread_create(&t1,NULL,refreshScreen,NULL);
    264. 	pthread_create(&t2,NULL,changeDir,NULL);
    265.  
    266. 	while(1);
    267. 	getch();//等待用户的输入，如果没有这句话，程序就退出了，看不到运行的结果，也就是无法看到上面那句话
    268. 	endwin();//程序退出，恢复shell终端的显示，如果没有这句话，shell终端字乱码，坏掉
    269.  
    270. 	return 0;
    271. }

  • 相关阅读:
    基于QT实现的图形软件图片编辑器
    使用scroll-view实现滑块视图可能遇到的问题及其解决方法
    c++获取当前时间的字符串
    C/S架构学习之使用epoll实现TCP特大型并发服务器
    Zabbix自动监控windows端口(主动监控方式)
    SSM框架整合
    常用的二十种设计模式（上）-C++
    idea2023根据表自动生成+springboot跑起来
    Stage #14 XSS注入：利用CSS内联注释突破防御
    Python数据结构：列表（list）、元组（tuple）、字典（dict）
  • 原文地址：https://blog.csdn.net/weixin_54859557/article/details/132948307