鱼C论坛

 找回密码
 立即注册
查看: 1641|回复: 16

[技术交流] 自己写第一个贪吃蛇游戏100%自己写的无cp

[复制链接]
发表于 2020-3-6 17:32:33 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能^_^

您需要 登录 才可以下载或查看,没有账号?立即注册

x
本帖最后由 就是要努力呀 于 2020-3-31 18:08 编辑

是在linux里写的那几个system是对控制台的设置,为了让scanf不用回车就直接运行
wiondos上可以自己更改一下

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <string.h>

  5. #define SNAKE 'o'
  6. #define FOOD '*'
  7. #define MAX 50

  8. typedef struct Snake
  9. {
  10.         int x;        //蛇的x坐标
  11.         int y;        //蛇的y坐标
  12.         struct Snake *per;
  13.         struct Snake *next;
  14. }
  15. Snake;

  16. int COUNT = 1;        //蛇的长度
  17. Snake *HEAD = NULL, *TAIL = NULL;        //蛇的头尾指针
  18. char FOOD_MAP[MAX][MAX];
  19. char MAP[MAX][MAX];

  20. void prinmain(void);        //打印主菜单
  21. void MAP_set_up(void);        //生成地图
  22. void FOOD_MAP_set_up(void);        //生成食物地图
  23. void snake_set_up(void);        //生成蛇
  24. void put_snake(void);        //将蛇放置在地图中
  25. void reset_MAP(void);        //刷新地图
  26. void print_all(void);        //打印所有物品
  27. int do_move(char move);        //判断蛇的移动
  28. int check_cross(void);        //检测蛇是否越界
  29. int check_kill(void);        //检测蛇是否碰到自己
  30. int check_food(void);        //检测蛇是否吃到食物
  31. void snake_add(char move);        //增加蛇的长度
  32. void game_over();        //游戏结束,释放链表

  33. void game_over()        //游戏结束,释放链表
  34. {
  35.         Snake *temp;

  36.         while(HEAD != NULL)
  37.         {
  38.                 temp = HEAD->next;
  39.                 free(HEAD);
  40.                 HEAD = temp;
  41.         }
  42. }

  43. void snake_add(char move)        //增加蛇的长度
  44. {
  45.         Snake *new;

  46.         new = (Snake *)malloc(sizeof(Snake));

  47.         if(new == NULL)
  48.         {
  49.                 printf("生成蛇失败!\n");

  50.                 exit(0);
  51.         }

  52.         switch(move)
  53.         {
  54.                 case 'w':
  55.                         new->x = TAIL->x + 1;
  56.                         new->y = TAIL->y;

  57.                         break;

  58.                 case 'a':
  59.                         new->y = TAIL->y + 1;
  60.                         new->x = TAIL->x;
  61.                        
  62.                         break;

  63.                 case 's':
  64.                         new->x = TAIL->x - 1;
  65.                         new->y = TAIL->y;

  66.                         break;

  67.                 case 'd':
  68.                         new->y = TAIL->y - 1;
  69.                         new->x = TAIL->x;

  70.                         break;
  71.         }

  72.         TAIL->next = new;
  73.         new->next = NULL;
  74.         TAIL = new;
  75. }

  76. int check_food(void)        //检测蛇是否吃到食物
  77. {
  78.         if(FOOD_MAP[HEAD->x][HEAD->y] == FOOD)
  79.         {
  80.                 FOOD_MAP[HEAD->x][HEAD->y] = ' ';

  81.                 return 1;
  82.         }

  83.         return 0;
  84. }

  85. int check_kill(void)        //检测蛇是否碰到自己
  86. {
  87.         Snake *temp;

  88.         temp = HEAD->next;

  89.         while(temp != NULL)
  90.         {
  91.                 if(HEAD->x == temp->x && HEAD->y == temp->y)
  92.                 {
  93.                         return 0;
  94.                 }

  95.                 temp = temp->next;
  96.         }

  97.         return 1;
  98. }

  99. int check_cross(void)        //检测蛇是否越界
  100. {
  101.         if(HEAD->x == 0 || HEAD->x == MAX - 1 || HEAD->y == 0 || HEAD->y == MAX - 1)
  102.         {
  103.                 return 0;
  104.         }

  105.         return 1;
  106. }

  107. int do_move(char move)        //判断蛇的移动
  108. {
  109.         int tempxy[COUNT][2];
  110.         int i = 0;
  111.         Snake *temp;

  112.         memset(tempxy, '0', COUNT * 2);

  113.         if(move == 'w' || move == 'a' || move == 's' || move == 'd')
  114.         {
  115.                 temp = HEAD;

  116.                 while(temp != NULL)
  117.                 {
  118.                         tempxy[i][0] = temp->x;
  119.                         tempxy[i][1] = temp->y;

  120.                         i++;

  121.                         temp = temp->next;
  122.                 }

  123.                 i = 0;

  124.                 temp = HEAD->next;

  125.                 while(temp != NULL)
  126.                 {
  127.                         temp->x = tempxy[i][0];
  128.                         temp->y = tempxy[i][1];

  129.                         i++;

  130.                         temp = temp->next;
  131.                 }

  132.                 temp = HEAD;


  133.                 switch(move)
  134.                 {

  135.                         case 'w':
  136.                                 HEAD->x = tempxy[0][0] - 1;

  137.                                 break;

  138.                         case 'a':
  139.                                 HEAD->y = tempxy[0][1] - 1;

  140.                                 break;

  141.                         case 's':
  142.                                 HEAD->x = tempxy[0][0] + 1;

  143.                                 break;

  144.                         case 'd':
  145.                                 HEAD->y = tempxy[0][1] + 1;

  146.                                 break;
  147.                 }

  148.                 if(!check_cross())
  149.                 {
  150.                         return 0;
  151.                 }

  152.                 if(!check_kill())
  153.                 {
  154.                         return 0;
  155.                 }

  156.                 if(check_food())
  157.                 {
  158.                         COUNT++;

  159.                         snake_add(move);
  160.                 }
  161.         }
  162.         else if(move == 'q')
  163.         {
  164.                 return 0;
  165.         }

  166.         return 1;
  167. }

  168. void print_all(void)        //打印所有物品
  169. {
  170.         static int count = 0;

  171.         printf("当前得分:%d\n", COUNT);

  172.         if(COUNT - count == 4)
  173.         {
  174.                 FOOD_MAP_set_up();

  175.                 count = COUNT;
  176.         }

  177.         reset_MAP();
  178.         put_snake();

  179.         for(int i = 0; i < MAX; i++)
  180.         {
  181.                 for(int j = 0; j < MAX ; j++)
  182.                 {
  183.                         if(FOOD_MAP[i][j] != ' ')
  184.                         {
  185.                                 printf("%c ", FOOD_MAP[i][j]);
  186.                         }
  187.                         else printf("%c ", MAP[i][j]);
  188.                 }

  189.                 putchar('\n');
  190.         }
  191. }

  192. void reset_MAP(void)        //刷新地图
  193. {
  194.         for(int i = 1; i < MAX - 1; i++)
  195.         {
  196.                 for(int j = 1; j < MAX - 1; j++)
  197.                 {
  198.                         MAP[i][j] = ' ';
  199.                 }
  200.         }
  201. }

  202. void put_snake(void)        //将蛇放置在地图中
  203. {
  204.         Snake *temp;

  205.         temp = HEAD->next;

  206.         MAP[HEAD->x][HEAD->y] = 'c';

  207.         while(temp != NULL)
  208.         {
  209.                 MAP[temp->x][temp->y] = SNAKE;

  210.                 temp = temp->next;
  211.         }
  212. }

  213. void snake_set_up(void)        //生成蛇
  214. {
  215.         HEAD = (Snake *)malloc(sizeof(Snake));

  216.         if(HEAD == NULL)
  217.         {
  218.                 printf("生成蛇失败!\n");

  219.                 exit(0);
  220.         }

  221.         srand(time(NULL) + 1);

  222.         do
  223.         {
  224.                 HEAD->x = rand()%MAX;
  225.                 HEAD->y = rand()%MAX;
  226.         }
  227.         while(HEAD->x == 0 || HEAD->x == MAX - 1 || HEAD->y == 0 || HEAD->y == MAX - 1);

  228.         HEAD->next = NULL;
  229.         TAIL = HEAD;
  230. }

  231. void FOOD_MAP_set_up(void)        //生成食物地图
  232. {
  233.         int i = 0, x, y;

  234.         memset(FOOD_MAP, ' ', MAX * MAX);

  235.         srand(time(NULL));

  236.         do
  237.         {
  238.                 i++;

  239.                 do
  240.                 {
  241.                         x = rand()%MAX;
  242.                         y = rand()%MAX;
  243.                 }
  244.                 while(x == 0 || x == MAX - 1 || y == 0 || y == MAX - 1);

  245.                 FOOD_MAP[x][y] = FOOD;
  246.         }
  247.         while(i != 4);
  248. }

  249. void MAP_set_up(void)        //生成地图
  250. {
  251.         memset(MAP, ' ', MAX * MAX);

  252.         for(int i = 0; i < MAX; i++)
  253.         {
  254.                 for(int j = 0; j < MAX; j++)
  255.                 {
  256.                         if(i == 0 || j == 0 || i == MAX - 1 || j == MAX - 1)
  257.                         {
  258.                                 MAP[i][j] = '0';
  259.                         }
  260.                         else MAP[i][j] = ' ';
  261.                 }
  262.         }
  263. }

  264. void prinmain(void)        //打印主菜单
  265. {
  266.         printf("1.开始游戏\n");
  267.         printf("2.结束游戏\n");
  268.         printf(":");
  269. }

  270. int main(void)
  271. {
  272.         char move;


  273.         prinmain();
  274.         scanf("%c", &move);
  275.         getchar();

  276.         if(move == '1')
  277.         {
  278.                 MAP_set_up();
  279.                 FOOD_MAP_set_up();
  280.                 snake_set_up();

  281.                 do
  282.                 {
  283.                         system("clear");
  284.                         print_all();

  285.                         printf("请输入指令(w/a/s/d/q):");

  286.                         system("stty raw -echo");

  287.                         scanf("%c", &move);

  288.                         system("stty cooked echo");
  289.                 }
  290.                 while(do_move(move));
  291.         }


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

  293.         system("stty cooked echo");

  294.         game_over();

  295.        
  296.         return 0;
  297. }
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

发表于 2020-3-6 17:35:07 | 显示全部楼层
贴代码用 "<>"
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2020-3-6 17:36:52 | 显示全部楼层

什么意思。。没懂
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2020-3-6 17:38:57 | 显示全部楼层

哦哦知道了谢谢提醒
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2020-3-6 17:45:54 | 显示全部楼层
大家可以给我说一下有什么清屏的函数
因为不知道所以我就用的linux控制台的clear命令
画面出来就是一张一张的
不过也不影响玩
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2020-3-6 18:20:15 | 显示全部楼层
就是要努力呀 发表于 2020-3-6 17:45
大家可以给我说一下有什么清屏的函数
因为不知道所以我就用的linux控制台的clear命令
画面出来就是一张一 ...

如果刷新频率不够,那就不要清屏,用gotoxy
https://bbs.csdn.net/topics/390687230

  1. #include <stdio.h>

  2. int main(void)
  3. {
  4.         printf("%c[%d;%df", 0x1b, 10, 10);
  5.         printf("hello\n");
  6.         return 0;
  7. }
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2020-3-6 18:28:20 | 显示全部楼层
人造人 发表于 2020-3-6 18:20
如果刷新频率不够,那就不要清屏,用gotoxy
https://bbs.csdn.net/topics/390687230

ok谢谢我去学习一下
不知道怎么用
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2020-3-7 18:47:57 | 显示全部楼层
代码抄完之后,排了下错,就成了下面这样了,但为什么我抄的代码不能玩呢?

  1. #include <stdio.h>
  2. #include <stdbool.h>
  3. #include <time.h>

  4. #define SNAKE 'O'
  5. #define FOOD '*'
  6. #define MAX 50

  7. typedef struct Snake
  8. {
  9.                 int x;                //蛇的x坐标
  10.                 int y;                //蛇的y坐标
  11.                 struct Snake *per;
  12.                 struct Snake *next;
  13. }
  14. Snake;

  15. int COUNT = 1;                //蛇的长度
  16. Snake * HEAD = NULL, *TAIL = NULL;                //蛇的头尾指针
  17. char FOOD_MAP [MAX][MAX];
  18. char MAP[MAX][MAX];

  19. void prinmain(void);                        //打印主菜单
  20. void MAP_set_up(void);                         //生成地图
  21. void FOOD_MAP_set_up(void);                //生成食物地图
  22. void snake_set_up(void);                //生成蛇
  23. void put_snake(void);                        //将蛇放置在地图中
  24. void reset_MAP(void);                        //刷新地图
  25. void print_all(void);                        //打印所有物品
  26. int do_move(char move);                        //判断蛇的移动
  27. int check_cross(void);                        //检测蛇是否越界
  28. int check_kill(void);                        //检测蛇是否碰到自己
  29. int check_food(void);                        //检测蛇是否吃到食物
  30. void snake_add(char move);                //增加蛇的长度
  31. void game_over();                                //游戏结束,释放链表

  32. void game_over()                                //游戏结束,释放链表
  33. {
  34.                 Snake *temp;
  35.                
  36.                 while(HEAD != NULL)
  37.                 {
  38.                                 temp = HEAD->next;
  39.                                 free(HEAD);
  40.                                 HEAD = temp;
  41.                 }
  42. }

  43. void snake_add(char move)                //增加蛇的长度
  44. {
  45.                 Snake *new;
  46.                
  47.                 new = (Snake *) malloc(sizeof(Snake));
  48.                
  49.                 if (new == NULL)
  50.                 {
  51.                                 printf ("生成蛇失败!\n");
  52.                                
  53.                                 exit(0);                                 
  54.                 }
  55.                
  56.                 switch (move)
  57.                 {
  58.                                 case 'w':
  59.                                         new->x = TAIL->x +1;
  60.                                         new->y = TAIL->y ;
  61.                                        
  62.                                         break;
  63.                                        
  64.                                 case 'a':
  65.                                         new->y = TAIL->y +1;
  66.                                         new->x = TAIL->x;
  67.                                        
  68.                                         break;
  69.                                        
  70.                                 case 's':
  71.                                         new->x = TAIL->x -1;
  72.                                         new->y = TAIL->y;
  73.                                        
  74.                                         break;
  75.                                        
  76.                                 case 'd':
  77.                                         new->y = TAIL->y -1;
  78.                                         new->x = TAIL->x;
  79.                                        
  80.                                         break;
  81.                 }
  82.                
  83.                 TAIL->next = new;
  84.                 new->next = new;
  85.                 TAIL = new;
  86. }

  87. int check_food(void)                //检测蛇是否吃到食物
  88. {
  89.                 if (FOOD_MAP[HEAD->x][HEAD->y] == FOOD)
  90.                 {
  91.                                 FOOD_MAP[HEAD->x][HEAD->y] = ' ';
  92.                                
  93.                                 return 1;
  94.                 }
  95.                
  96.                 return 0;                       
  97. }

  98. int check_kill(void)                //检测蛇是否碰到自己
  99. {
  100.                 Snake *temp;
  101.                
  102.                 temp = HEAD->next;
  103.                
  104.                 while (temp != NULL)
  105.                 {
  106.                                 if (HEAD->x == temp->x && HEAD->y == temp->y)
  107.                                 {
  108.                                                 return 0;
  109.                                 }
  110.                                
  111.                                 temp = temp->next;
  112.                 }
  113.                
  114.                 return 1;
  115. }

  116. int check_cross(void)                //检测蛇是否越界
  117. {
  118.                 if (HEAD->x == 0 || HEAD->x == MAX -1 || HEAD->y == 0 || HEAD->y == MAX -1)
  119.                 {
  120.                                 return 0;
  121.                 }
  122.                
  123.                 return 1;
  124. }

  125. int do_move (char move)                //判断蛇的移动
  126. {
  127.                 int tempxy[COUNT][2];
  128.                 int i = 0;
  129.                 Snake * temp;
  130.                
  131.                 memset (tempxy, '0' , COUNT * 2 );
  132.                
  133.                 if (move == 'w' || move == 'a' || move == 's' || move == 'd')
  134.                 {
  135.                                 temp = HEAD;
  136.                                
  137.                                 while (temp != NULL)
  138.                                 {
  139.                                                 tempxy[i][0] = temp->x;
  140.                                                 tempxy[i][1] = temp->y;
  141.                                                
  142.                                                 i++;
  143.                                                
  144.                                                 temp = temp -> next ;
  145.                                 }
  146.                                
  147.                                 i = 0;
  148.                                
  149.                                 temp = HEAD -> next;
  150.                                
  151.                                 while (temp != NULL)
  152.                                 {
  153.                                                 temp -> x = tempxy[i][0];
  154.                                                 temp -> y = tempxy[i][1];
  155.                                                
  156.                                                 i++;
  157.                                                
  158.                                                 temp = temp -> next;
  159.                                 }
  160.                                
  161.                                 temp = HEAD;
  162.                                
  163.                                 switch(move)
  164.                                 {
  165.                                                 case 'w':
  166.                                                         HEAD->x = tempxy[0][0] - 1;
  167.                                                        
  168.                                                         break;
  169.                                                        
  170.                                                 case 'a':
  171.                                                         HEAD->y = tempxy[0][1] - 1;
  172.                                                        
  173.                                                         break;
  174.                                                        
  175.                                                 case 's':
  176.                                                         HEAD->x = tempxy[0][0] + 1;
  177.                                                        
  178.                                                         break;
  179.                                                        
  180.                                                 case 'd':
  181.                                                         HEAD->y        = tempxy[0][1] + 1;
  182.                                                        
  183.                                                         break;                                               
  184.                                 }
  185.                                
  186.                                 if (!check_cross())
  187.                                 {
  188.                                                 return 0;
  189.                                 }
  190.                                
  191.                                 if (!check_kill())
  192.                                 {
  193.                                                 return 0;
  194.                                 }
  195.                                
  196.                                 if (!check_food())
  197.                                 {
  198.                                                 COUNT++;
  199.                                                
  200.                                                 snake_add(move);
  201.                                 }
  202.                 }
  203.                 else if (move == 'q')
  204.                 {
  205.                                 return 0;
  206.                 }
  207.                
  208.                 return 1;
  209. }

  210. void print_all(void)                //打印所有物品
  211. {
  212.                 static int count = 0;
  213.                
  214.                 printf ("当前得分:%d\n", COUNT);
  215.                
  216.                 if (COUNT - count == 4)
  217.                 {
  218.                                 FOOD_MAP_set_up();
  219.                                
  220.                                 count = COUNT;
  221.                 }
  222.                
  223.                 reset_MAP();
  224.                 put_snake();
  225.                
  226.                 int i;
  227.                 for(i = 0; i < MAX; i++)
  228.                 {
  229.                                 int j;
  230.                                 for (j = 0; j < MAX; j++)
  231.                                 {
  232.                                                 if (FOOD_MAP[i][j] != ' ')
  233.                                                 {
  234.                                                                 printf ("%c", FOOD_MAP[i][j]);
  235.                                                 }
  236.                                                 else printf ("%c", MAP[i][j]);
  237.                                 }
  238.                                
  239.                                 putchar('\n');
  240.                  }
  241. }

  242. void reset_MAP(void)                //刷新地图
  243. {
  244.                 int i;
  245.                 for (i =1; i < MAX -1; i++)
  246.                 {
  247.                                 int j;
  248.                                 for (j =1; j < MAX -1; j++)
  249.                                 {
  250.                                                 MAP[i][j] = ' ';
  251.                                 }
  252.                 }
  253. }

  254. void put_snake(void)                //将蛇放置在地图中
  255. {
  256.                 Snake * temp;
  257.                
  258.                 temp = HEAD -> next;
  259.                
  260.                 MAP[HEAD->x][HEAD->y] = 'c';
  261.                
  262.                 while (temp != NULL)
  263.                 {
  264.                                 MAP[temp->x][temp->y] = SNAKE;
  265.                                
  266.                                 temp = temp->next;
  267.                 }
  268. }

  269. void snake_set_up(void)                //生成蛇
  270. {
  271.                 HEAD = (Snake *) malloc (sizeof(Snake));
  272.                
  273.                 if (HEAD == NULL)
  274.                 {
  275.                                 printf ("生成蛇失败!\n");
  276.                                
  277.                                 exit(0);
  278.                 }
  279.                
  280.                 srand (time(NULL) +1);
  281.                
  282.                 do
  283.                 {
  284.                                 HEAD->x = rand()%MAX;
  285.                                 HEAD->y = rand()%MAX;
  286.                 }
  287.                
  288.                 while (HEAD->x == 0 || HEAD->x == MAX -1 || HEAD->y == 0 || HEAD->y == MAX -1);
  289.                
  290.                 HEAD-> next = NULL;
  291.                 TAIL = HEAD;
  292. }

  293. void FOOD_MAP_set_up(void)                //生成食物地图
  294. {
  295.                 int i = 0, x, y;
  296.                
  297.                 memset (FOOD_MAP, ' ', MAX * MAX);
  298.                
  299.                 srand (time (NULL));
  300.                
  301.                 do
  302.                 {
  303.                                 i++;
  304.                                
  305.                                 do
  306.                                 {
  307.                                                 x = rand()%MAX;
  308.                                                 y = rand()%MAX;
  309.                                 }
  310.                                 while (x == 0 || x == MAX -1 || y == 0 || y == MAX -1);
  311.                                
  312.                                 FOOD_MAP[x][y] = FOOD;
  313.                 }
  314.                 while(i!=4);
  315. }

  316. void MAP_set_up(void)                //生成地图
  317. {
  318.                 memset (MAP, ' ', MAX * MAX);
  319.                
  320.                 int i;
  321.                 for (i = 0; i < MAX; i++)
  322.                 {
  323.                                 int j;
  324.                                 for (j = 0; j < MAX; j++)
  325.                                 {       
  326.                                                 if (i == 0 || j == 0 || i == MAX -1 || j == MAX -1)
  327.                                                 {
  328.                                                                 MAP[i][j] = '0';                                               
  329.                                                 }
  330.                                                 else MAP[i][j] = ' ';
  331.                                 }
  332.                 }               
  333. }

  334. void prinmain (void)                //打印主菜单
  335. {
  336.                 printf("1.开始游戏\n");
  337.                 printf("2.结束游戏\n");
  338.                 printf(":");
  339. }

  340. int main(void)
  341. {
  342.                 char move;
  343.                
  344.                 prinmain();
  345.                 scanf("%c",&move);
  346.                 getchar();
  347.                
  348.                 if(move == '1')
  349.                 {
  350.                                 MAP_set_up();
  351.                                 FOOD_MAP_set_up();
  352.                                 snake_set_up();
  353.                                
  354.                                 do
  355.                                 {
  356.                                                 system("clear");
  357.                                                 print_all();
  358.                                                
  359.                                                 printf("请输入指令(w/a/s/d/q):");
  360.                                                
  361.                                                 system("stty raw -echo");
  362.                                                
  363.                                                 scanf("%c", &move);
  364.                                                
  365.                                                 system("stty cooked echo");
  366.                                 }
  367.                                 while(do_move(move));
  368.                 }
  369.                
  370.                 printf("\n游戏结束\n");
  371.                
  372.                 system("stty cooked echo");
  373.                
  374.                 game_over();
  375.                
  376.                 return 0;
  377. }

复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2020-3-7 19:05:13 From FishC Mobile | 显示全部楼层
碧水青鱼 发表于 2020-3-7 18:47
代码抄完之后,排了下错,就成了下面这样了,但为什么我抄的代码不能玩呢?

你是用的编译器还是在Linux下运行的
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2020-3-7 19:07:03 From FishC Mobile | 显示全部楼层
就是要努力呀 发表于 2020-3-7 19:05
你是用的编译器还是在Linux下运行的

我是在Linux里写的如果是编译器的话你应该要自己申请一个窗口 然后把system("clear")用gotoxy代替 还有另外system删除掉
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2020-3-7 19:09:41 From FishC Mobile | 显示全部楼层
就是要努力呀 发表于 2020-3-7 19:07
我是在Linux里写的如果是编译器的话你应该要自己申请一个窗口 然后把system("clear")用gotoxy代替 还有另 ...

我也不知道编译器可不可以用system
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2020-3-7 19:19:25 | 显示全部楼层
碧水青鱼 发表于 2020-3-7 18:47
代码抄完之后,排了下错,就成了下面这样了,但为什么我抄的代码不能玩呢?

你可以把错误信息贴出来看一下
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2020-3-7 20:44:24 | 显示全部楼层
本帖最后由 碧水青鱼 于 2020-3-7 20:46 编辑
就是要努力呀 发表于 2020-3-7 19:19
你可以把错误信息贴出来看一下


不是说你的代码不好,是我自己抄得有问题,很多标点符号,大小写什么的抄错了,我说的排错是主要排这个错。另外有个问题是代码编译到
  1. for(int ...)
复制代码

这个地方就运行不下去,我百度查了一下,好像说int不能放在括号里面,要写成
  1. int i;
  2. for (i = 0; i < MAX; i++)
复制代码

这样的格式才行,然后我照着改了,确实就可以往下编译了

然后,这代码抄完之后,虽然可以运行,但好像玩不了游戏,不知道怎么回事
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2020-3-7 20:49:39 | 显示全部楼层
就是要努力呀 发表于 2020-3-7 19:05
你是用的编译器还是在Linux下运行的

用的Dev编译器
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2020-3-7 21:23:23 From FishC Mobile | 显示全部楼层
没有报错没有警告就是对的呀
你看你键盘是不是开的大写
我偷懒没有写大写
只有小写才行
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

发表于 2020-3-8 01:34:26 | 显示全部楼层
就是要努力呀 发表于 2020-3-7 21:23
没有报错没有警告就是对的呀
你看你键盘是不是开的大写
我偷懒没有写大写


添加大写很容易的

  1.         switch(move)
  2.         {
  3.                 case 'w':
  4.                 case 'W':
  5.                         HEAD->x = tempxy[0][0] - 1;
  6.                         break;
  7.                 case 'a':
  8.                 case 'A':
  9.                         HEAD->y = tempxy[0][1] - 1;
  10.                         break;
  11.                 case 's':
  12.                 case 'S':
  13.                         HEAD->x = tempxy[0][0] + 1;
  14.                         break;
  15.                 case 'd':
  16.                 case 'D':
  17.                         HEAD->y = tempxy[0][1] + 1;
  18.                         break;
  19.         }
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2020-3-8 10:40:20 From FishC Mobile | 显示全部楼层
人造人 发表于 2020-3-8 01:34
添加大写很容易的

我就是赶个懒没有写这个贪吃蛇我写了10个小时
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-7-3 23:08

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表