devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言——贪吃蛇小游戏_c语言制作贪吃蛇

作者：凡人多烦事01 | 2024-04-21 14:19:29

赞

踩

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 <curses.h>
    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 <curses.h>
  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 <curses.h>
  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 <curses.h>
  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 <curses.h>
  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 <curses.h>
  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 <curses.h>
  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 <curses.h>
  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 <curses.h>
  2. #include <stdlib.h>
  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 <curses.h>
  2. #include <stdlib.h>
  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();			//必须刷新一下界面，否则看不到
    声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/463454
    推荐阅读
    相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。