请选择 进入手机版 | 继续访问电脑版
工作室 好人游戏乱跑,解决方案 投稿
鼠标 宏命令 手游 工作室文化
快打器 微信 常见问题 常用平板与手机
魔兽视频
查看: 1215|回复: 0

[C语言] C语言实现最简单的2048小游戏

[复制链接]
  • TA的每日心情
    开心
    2019-9-24 12:14
  • 签到天数: 5 天

    连续签到: 1 天

    [LV.2]偶尔看看I

    405

    主题

    1454

    帖子

    6601

    积分

    实习版主

    Rank: 7Rank: 7Rank: 7

    UID
    19
    帖子
    1454
    精华
    2
    威望
    551
    贡献
    135
    虾币
    3902
    阅读权限
    100
    注册时间
    2013-9-14

    热心会员永不封号灌水之王勤奋版主游戏达人美女勋章

    发表于 2019-10-11 14:46:55 | 显示全部楼层 |阅读模式
    网上解释很多了,直接上代码吧,这个功能很简单,易于学习,后期有时间会完善功能。


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

    4. #define Key_Up 0x4800 // 向上方向键   
    5. #define Key_Down 0x5000 // 向下方向键
    6. #define Key_Right 0x4d00 // 向右方向键
    7. #define Key_Left 0x4b00 // 向左方向键


    8. int map[4][4] = { 0 };
    9. int check[4] = { 0 };  //判断游戏是否结束,如果都不为0,游戏结束
    10. int i, j;

    11. //
    12. //显示在屏幕上
    13. //
    14. void print()
    15. {
    16.         for (i = 0; i < 4; i++)
    17.         {
    18.                 for (j = 0; j < 4; j++)
    19.                 {
    20.                         printf("%d\t", map[i][j]);
    21.                 }
    22.                 printf("\n");
    23.         }
    24. }


    25. //
    26. //向右移动
    27. //
    28. int moveRight() {
    29.         int flag = 0;  //来标记是否整个map矩阵能否改变,以此判断整个游戏是否结束
    30.         //这个循环的目的是为了做某一行的加减,如某一行为[2 2 4 4],经过以下运算就会变为[0 4 0 8];
    31.         for (i = 0; i < 4; i++)
    32.         {
    33.                 for (j = 4 - 1; j >= 0; j--)
    34.                 {
    35.                         int cell = map[i][j];
    36.                         if (cell != 0)
    37.                         {
    38.                                 int k = j - 1;
    39.                                 while (k >= 0)
    40.                                 {
    41.                                         int nextcell = map[i][k];
    42.                                         if (nextcell != 0)
    43.                                         {
    44.                                                 if (cell == nextcell)
    45.                                                 {
    46.                                                         flag = 1;
    47.                                                         map[i][j] += map[i][k];
    48.                                                         map[i][k] = 0;
    49.                                                 }
    50.                                                 k = -1;
    51.                                                 break;
    52.                                         }
    53.                                         k--;
    54.                                 }
    55.                         }
    56.                 }
    57.         }

    58.         //上一步做的是数据加减,这一步对加减后的数据做数据处理
    59.         //例如某一行经过上一步的数据为【0 4 0 8】,将会变为【0 0 4 8】
    60.         for (i = 0; i < 4; i++)
    61.         {
    62.                 for (j = 4 - 1; j > 0; j--)
    63.                 {
    64.                         int cell = map[i][j];
    65.                         if (cell == 0)
    66.                         {

    67.                                 int k = j - 1;
    68.                                 while (k >= 0)
    69.                                 {
    70.                                         int nextcell = map[i][k];
    71.                                         if (nextcell != 0)
    72.                                         {
    73.                                                 flag = 1;//当前元素为0,说明能移动,改变flag的值
    74.                                                 map[i][j] = nextcell;
    75.                                                 map[i][k] = 0;
    76.                                                 k = -1;
    77.                                         }
    78.                                         k--;
    79.                                 }
    80.                         }
    81.                 }
    82.         }
    83.         if (flag)
    84.                 return 0;
    85.         else
    86.                 return 4;  //游戏结束
    87. }


    88. //
    89. //向左移动
    90. //
    91. int moveLeft() {
    92.         int flag=0;
    93.         for (i = 0; i < 4; i++)
    94.         {
    95.                 for (j = 0; j < 4; j++)
    96.                 {
    97.                         int cell = map[i][j];//cell单词用的不太恰当,表示当前元素,你可以采用更有意义的命名
    98.                         if (cell != 0)
    99.                         {
    100.                                 int k = j + 1;
    101.                                 while (k < 4)
    102.                                 {
    103.                                         int nextcell = map[i][k];
    104.                                         if (nextcell != 0)
    105.                                         {
    106.                                                 if (cell == nextcell)
    107.                                                 {
    108.                                                         flag = 1;//相邻两个元素相同,就说明能移动,所以改变flag的值
    109.                                                         map[i][j] += map[i][k];
    110.                                                         map[i][k] = 0;
    111.                                                 }
    112.                                                 k = 4;
    113.                                                 break;
    114.                                         }
    115.                                         k++;
    116.                                 }
    117.                         }
    118.                 }
    119.         }

    120.         //修改部分:for循环中的i或者j的循环条件

    121.         for (i = 0; i < 4; i++)
    122.         {
    123.                 for (j = 0; j < 4 - 1; j++)
    124.                 {
    125.                         int cell = map[i][j];
    126.                         if (cell == 0)
    127.                         {
    128.                                 int k = j + 1;
    129.                                 while (k < 4)
    130.                                 {
    131.                                         int nextcell = map[i][k];
    132.                                         if (nextcell != 0)
    133.                                         {
    134.                                                 flag = 1;
    135.                                                 map[i][j] = nextcell;
    136.                                                 map[i][k] = 0;
    137.                                                 k = 4;
    138.                                         }
    139.                                         k++;
    140.                                 }
    141.                         }
    142.                 }
    143.         }
    144.         if (flag)
    145.                 return 0;
    146.         else
    147.                 return 3;
    148. }


    149. //
    150. //向下移动
    151. //
    152. int moveDown() {
    153.         int flag=0;
    154.         for (i = 4 - 1; i >= 0; i--)
    155.         {
    156.                 for (j = 0; j < 4; j++)
    157.                 {
    158.                         int cell = map[i][j];

    159.                         if (cell != 0)
    160.                         {
    161.                                 int k = i - 1;
    162.                                 while (k >= 0)
    163.                                 {
    164.                                         int nextcell = map[k][j];
    165.                                         if (nextcell != 0)
    166.                                         {
    167.                                                 if (map[i][j] == map[k][j])
    168.                                                 {
    169.                                                         flag = 1;
    170.                                                         map[i][j] += map[k][j];
    171.                                                         map[k][j] = 0;
    172.                                                 }
    173.                                                 k = 0;
    174.                                                 break;
    175.                                         }
    176.                                         k--;
    177.                                 }
    178.                         }
    179.                 }
    180.         }

    181.         //修改部分:for循环中的i或者j的循环条件
    182.         for (i = 4 - 1; i > 0; i--)
    183.         {
    184.                 for (j = 0; j < 4; j++)
    185.                 {
    186.                         int cell = map[i][j];
    187.                         if (cell == 0)
    188.                         {
    189.                                 int k = i - 1;
    190.                                 while (k >= 0)
    191.                                 {
    192.                                         int nextcell = map[k][j];
    193.                                         if (nextcell != 0)
    194.                                         {
    195.                                                 flag = 1;
    196.                                                 map[i][j] = nextcell;
    197.                                                 map[k][j] = 0;
    198.                                                 k = 0;
    199.                                         }
    200.                                         k--;
    201.                                 }
    202.                         }
    203.                 }
    204.         }
    205.         if (flag)
    206.                 return 0;
    207.         else
    208.                 return 2;
    209. }

    210. //
    211. //向上移动
    212. //
    213. int moveUp() {
    214.         int flag=0;
    215.         for (i = 0; i < 4; i++)
    216.         {
    217.                 for (j = 0; j < 4; j++)
    218.                 {
    219.                         int cell = map[i][j];

    220.                         if (cell != 0)
    221.                         {
    222.                                 int k = i + 1;
    223.                                 while (k < 4)
    224.                                 {
    225.                                         int nextcell = map[k][j];
    226.                                         if (nextcell != 0)
    227.                                         {
    228.                                                 if (cell == nextcell)
    229.                                                 {
    230.                                                         flag = 1;
    231.                                                         map[i][j] += map[k][j];
    232.                                                         map[k][j] = 0;
    233.                                                 }
    234.                                                 k = 4;
    235.                                                 break;
    236.                                         }
    237.                                         k++;
    238.                                 }
    239.                         }
    240.                 }
    241.         }

    242.         //修改部分:for循环中的i或者j的循环条件
    243.         for (i = 0; i < 4 - 1; i++)
    244.         {
    245.                 for (j = 0; j < 4; j++)
    246.                 {
    247.                         int cell = map[i][j];
    248.                         if (cell == 0)
    249.                         {

    250.                                 int k = i + 1;
    251.                                 while (k < 4)
    252.                                 {
    253.                                         int nextcell = map[k][j];
    254.                                         if (nextcell != 0)
    255.                                         {
    256.                                                 flag = 1;
    257.                                                 map[i][j] = nextcell;
    258.                                                 map[k][j] = 0;
    259.                                                 k = 4;
    260.                                         }
    261.                                         k++;
    262.                                 }
    263.                         }
    264.                 }
    265.         }
    266.         if (flag==0)
    267.                 return 0;
    268.         else
    269.                 return 1;
    270. }


    271. //
    272. //随机生成在空格上生成2或者4,并且判断是否游戏结束
    273. //
    274. int randInteger()  //有缺陷,【0 0 0 0】
    275. {
    276.         for (i = 0; i < 4; i++)
    277.         {
    278.                 for (j = 0; j < 4; j++)
    279.                 {
    280.                         if (map[i][j] == 0)
    281.                         {
    282.                                 map[i][j] = (rand() % 2 + 1) * 2;   //
    283.                                 return 0;
    284.                         }
    285.                 }
    286.         }
    287.         return 0;
    288. }



    289. int main()
    290. {
    291.         print();
    292.         char key;
    293.         while (1)
    294.         {
    295.                 printf("上:w;下:s;左:a;右:d;退出:q\n");
    296.                 printf("请输入要执行的操作:");
    297.                 scanf("%c", &key);
    298.                 switch (key)
    299.                 {
    300.                 case 'w':
    301.                 {
    302.                                 randInteger();
    303.                                 moveUp();
    304.                                 printf(" 向上方向键被按下\n");
    305.                                 print();
    306.                                 break;
    307.                 }
    308.                 case 's':
    309.                 {
    310.                         randInteger();
    311.                         moveDown();
    312.                         printf(" 向下方向键被按下\n");
    313.                         print();
    314.                         break;
    315.                 }
    316.                 case 'a':
    317.                 {
    318.                         randInteger();
    319.                         moveLeft();
    320.                         printf(" 向左方向键被按下\n");
    321.                         print();
    322.                         break;
    323.                 }
    324.                 case 'd':
    325.                 {
    326.                         randInteger();
    327.                         moveRight();
    328.                         printf(" 向右方向键被按下\n");
    329.                         print();
    330.                         break;
    331.                 }
    332.                 case 'q':
    333.                         return 0;
    334.                 }
    335.         }
    336.         return 0;
    337. }
    复制代码



    该会员没有填写今日想说内容.
    高级模式
    B Color Image Link Quote Code Smilies

    本版积分规则