设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › C\C++交流 › C语言，2048游戏文字版，流程逻辑思路，代码详解(中)
返回列表 发新帖
查看: 1756|回复: 0

[技术交流] C语言，2048游戏文字版，流程逻辑思路，代码详解(中)

[复制链接]
Stubborn
发表于 2021-5-12 16:14:36 | 显示全部楼层 |阅读模式

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

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

x
本帖最后由 Stubborn 于 2021-5-12 18:01 编辑

C语言，2048游戏文字版，流程逻辑思路，代码详解(中)


上一篇已经实现了大部分的绘制函数，这部分开始实现游戏的逻辑函数
⑤bool GeneratingRandomNumbers(struct Game *);大致逻辑是，随机生成2或者4，都是1/2的概率，然后随机生成一个索引，在数据列表中为0的位置跟新
  1. bool GeneratingRandomNumbers(struct Game *data){
  2.     /**Generate a random number and place it in a random position where the data parameter is not 0。
  3.      *If the modification is successful, return true; otherwise, return false。
  4.      */
  5.     srand(time(NULL));

  7.     short value = ((const short []){2, 4})[randint(2)];
  8.     size_t randomIndex = (size_t) randint(data->length);
  9.     data->score += value;
  10.     data->move += 1;

  12.     for (size_t rightIndex = randomIndex; rightIndex < data->length; ++rightIndex)
  13.     {
  14.         if (data->arr[rightIndex]==0)
  15.         {
  16.             data->arr[rightIndex] = value;
  17.             return true;
  18.         }

  20.     }

  22.     for (size_t leftIndex = randomIndex; leftIndex > 0; --leftIndex)
  23.     {
  24.         if (data->arr[leftIndex]==0)
  25.         {
  26.             data->arr[leftIndex] = value;
  27.             return true;
  28.         }
  29.     }
  30.     return false;

  32. }
复制代码


好了，写到这里，开始回顾一下，实现的什么功能，以及程序的运行流程。
1.程序运行，展示一个欢迎界面，并提供输入选择。
2.输入对应的选择会有对应的界面
3.选择开始游戏后，生成一个随机数，并且打印出游戏界面。
那么接下来，我们就应该编写监听键盘的输入的函数，并实现⑥数字的移动以及合并选择。
首先是监听键盘的输入的函数bool JudgmentInput(int, struct Game *);   
根据对应的键盘操作，调用不同的移动函数，当游戏可以发生移动，或者合并的时候，返回一个true。否则返回一个false。
其次当操作成功之后，在生成一个随机数，操作失败检测下当前游戏是不是可以结束，即当前游戏不能发生移动，合并的情况。
不管成功或者失败，都看下有没有到胜利条件，看下合成的数字有没有到2048。然后再次绘制游戏界面，跟新游戏状态。

函数bool JudgmentInput(int, struct Game *); 实现的逻辑是：
当键盘发生了上下左右的操作，调用对应的移动合并操作。
如果移动合并操作失败，或者发生其他的操作，检查游戏是不是结束，或者胜利。
再次打印游戏界面
  1. bool JudgmentInput(int key, struct Game *data){
  2.     bool flag = false;
  3.     switch (key) {  ////LEFT = 75, UP = 72, RIGHT = 77, DOWN = 80, Esc=27
  4.         case 72:
  5.             flag = MoveUp(data);
  6.             break;
  7.         case 80:
  8.             flag =  MoveDown(data);
  9.             break;
  10.         case 75:
  11.             flag =  MoveLeft(data);
  12.             break;
  13.         case 77:
  14.             flag =  MoveRight(data);
  15.             break;
  16.         case 27:
  17.             exit(0);
  18.     }
  19.     if (flag){
  20.         GeneratingRandomNumbers(data);
  21.     } else {
  22.         DrawLoser(data);
  23.     }
  24.     DrawWin(*data);
  25.     DrawTheGameBox(*data);
  26.     return flag;
  27. }
复制代码



在void StartGame()函数里面死循环，监听键盘操作
  1. void StartGame(){
  2.     /**Start the game, run the logic of the game
  3.      * */
  4.     bool True = true;
  5.     struct Game data= {16, {0}, 0, 0, 0, time(NULL)};
  6.     struct Game *p = &data;
  7.     GeneratingRandomNumbers(p);
  8.     DrawTheGameBox(data);
  9.     // 监听键盘
  10.     while (True)
  11.     {
  12.         while (kbhit())
  13.         {
  14.             JudgmentInput(getch(), p);
  15.         }
  16.     }
  17. }
复制代码




现在开始实现⑥部分的数字合并部分，也是整个游戏的逻辑核心。首先看图。

移动合并.png


首先看左侧，游戏往上移动。2048游戏的逻辑是什么？
数字向上移动，如果相邻的两个各自数字一样，则合并成一个新数字。

所以我们实现的逻辑是什么？具体如何实现？
我们需要实现数字移动，以及数字的合并。

怎么移动数字，一个最基本的逻辑 ，当遍历到数值为0的时候，那么表明这个位置可以被填充的，0下方的数字都可以移动。用编程表达就是这两个位置可以交换
  1. arr[index] = arr[index-4];
  2. arr[index-4] = 0;
复制代码


注意，因为我这里使用的是一维数组，表达方式不一样。实际看个人的数据进行表达。一定要注意数组的越界，我们应该遍历到第三层就停止遍历。
当我们整个遍历一次后，会发生什么?可以移动的数字，全部往上移动了一层。那么我们重复这个步骤，那么就可以全部进行移动


怎么进行数字的合并。和移动数字的逻辑差不多，当遍历数组的时候，发现当前遍历的索引index 和 index + 4 值一样，即上下两个值一样，就可以进行合并。用编程表达就是这两个位置发生改变：
  1. arr[index] *= 2;
  2. arr[index-4] = 0;
复制代码



合并之后，又会出现 0 的空位，此时我们再次调用移动函数，进行移动即可完成一次的移动操作
  1. bool _MoveUp(struct Game *data){
  2.     bool flag = false;
  3.     for (size_t _index = 4; _index < data->length; _index+=4)
  4.     {
  5.         for (size_t index = 4; index < data->length; ++index)
  6.         {
  7.             if (data->arr[index-4] == 0 && data->arr[index] !=0)
  8.             {
  9.                 data->arr[index-4] = data->arr[index];
  10.                 data->arr[index] = 0;
  11.                 flag = true;
  12.             }
  13.         }
  14.     }
  15.     return flag;
  16. }

  18. bool MoveUp(struct Game *data){
  19.     // 上移操作，需要实现的逻辑有，数字的移动以及合并，是否是有效的移动
  20.     bool flag = false;
  21.     flag = _MoveUp(data);
  22.     for (size_t index = 0; index < data->length-4; ++index) {
  23.         if (data->arr[index] == data->arr[index+4] && data->arr[index] != 0)
  24.         {
  25.             data->arr[index] *= 2;
  26.             if (data->arr[index] > data->max){
  27.                 data->max = data->arr[index];
  28.             }
  29.             data->arr[index+4] = 0;
  30.             flag = true;
  31.         }
  32.     }
  33.     _MoveUp(data);
  34.     return flag;
  35. }

  37. bool _MoveLeft(struct Game *data)
  38. {
  39.     bool flag = false;
  40.     for (size_t _index = 4; _index < data->length; _index+=4)
  41.     {
  42.         for (size_t index = 0; index < data->length; index+=4)
  43.         {
  44.             for (size_t i = 0; i < 4 - 1; ++i)
  45.             {
  46.                 if (data->arr[index + i] == 0 && data->arr[index+i+1] != 0)
  47.                 {
  48.                     data->arr[index+i] = data->arr[index+i+1];
  49.                     data->arr[index+i+1] = 0;
  50.                     flag = true;
  51.                 }
  52.             }
  53.         }
  54.     }
  55.     return flag;

  57. }

  59. bool MoveLeft(struct Game *data)
  60. {
  61.     bool flag = false;
  62.     flag = _MoveLeft(data);
  63.     for (size_t index = 0; index < data->length; index+=4)
  64.     {
  65.         for (size_t i = 0; i < 4 - 1; ++i)
  66.         {
  67.             if (data->arr[index + i] == data->arr[index + i + 1] && data->arr[index + i]  != 0)
  68.             {
  69.                 data->arr[index+i] *= 2;
  70.                 if (data->arr[index+i] > data->max){
  71.                     data->max = data->arr[index+i];
  72.                 }
  73.                 data->arr[index+i+1] = 0;
  74.                 flag = true;
  75.             }
  76.         }
  77.     }
  78.     _MoveLeft(data);
  79.     return flag;

  81. }

  83. bool _MoveRight(struct Game *data)
  84. {
  85.     bool flag = false;
  86.     for (size_t _index = 4; _index < data->length; _index+=4)
  87.     {
  88.         for (size_t index = 3; index < data->length; index+=4) // 3  7  11 15
  89.         {
  90.             for (size_t i = 0; i < 4 - 1; ++i)
  91.             {
  92.                 if (data->arr[index - i] == 0 && data->arr[index-i-1] != 0)
  93.                 {
  94.                     data->arr[index - i] = data->arr[index-i-1];
  95.                     data->arr[index- i -1] = 0;
  96.                     flag = true;
  97.                 }
  98.             }
  99.         }
  100.     }
  101.     return flag;
  102. }

  104. bool MoveRight(struct Game *data)
  105. {
  106.     bool flag = false;
  107.     flag = _MoveRight(data);
  108.     for (size_t index = 3; index < data->length; index+=4) // 3  7  11 15
  109.     {
  110.         for (size_t i = 0; i < 4 - 1; ++i)
  111.         {
  112.             if (data->arr[index - i] == data->arr[index- i -1] && data->arr[index- i -1] != 0) // 0 1 2
  113.             {
  114.                 data->arr[index - i] *= 2;
  115.                 if (data->arr[index-i] > data->max){
  116.                     data->max = data->arr[index-i];
  117.                 }
  118.                 data->arr[index- i -1] = 0;
  119.                 flag = true;
  120.             }
  121.         }
  122.     }
  123.     _MoveRight(data);
  124.     return flag;

  126. }

  128. bool _MoveDown(struct Game *data)
  129. {
  130.     bool flag = false;
  131.     for (size_t _index = 4; _index < data->length; _index+=4)
  132.     {
  133.         for (size_t index = data->length - 1; index >= 4; --index)
  134.         {
  135.             if (data->arr[index] == 0 && data->arr[index-4] !=0)
  136.             {
  137.                 data->arr[index] = data->arr[index-4];
  138.                 data->arr[index-4] = 0;
  139.                 flag = true;
  140.             }
  141.         }
  142.     }
  143.     return flag;
  144. }

  146. bool MoveDown(struct Game *data)
  147. {
  148.     bool flag = false;
  149.     flag = _MoveDown(data);
  150.     for (size_t index = data->length - 1; index >= 4; --index)
  151.     {
  152.         if (data->arr[index] == data->arr[index-4] && data->arr[index-4] !=0)
  153.         {
  154.             data->arr[index] *=2 ;
  155.             if (data->arr[index] > data->max){
  156.                 data->max = data->arr[index];
  157.             }
  158.             data->arr[index-4] = 0;
  159.             flag = true;
  160.         }
  161.     }
  162.     _MoveDown(data);
  163.     return flag;
  164. }
复制代码





小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

GMT+8, 2025-4-29 10:38

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

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