大家都知道2048是一款流行的数字游戏，玩法也比较简单。我们每次可以选择上下左右其中一个方向去滑  动，每滑动一次，所有的数字方块都会往滑动的方向靠拢外，系统也会在空白的地方乱数出现一个数字方块，相  同数字的方块在靠拢、相撞时会相加。不断的叠加最终拼凑出2048这个数字就算成功。哈哈，只要掌握相应的  技巧相信大家都可以赢。 
      同时，这也是C语言老师留给我们的一个小项目作业，用C语言实现无界面的简易版“2048”。
      通过好多次体验此游戏，我们终于可以熟悉其基本操作和逻辑关系，接着得整理思路，用代码去实现。
      分析如下：1.游戏的数字我们由4X4数组实现，其中变换的就是元素。
                      2.数字是随机位置随机产生2或者4，要用随机数函数rand（）具体实现。
                      3还需要上下左右的移动时数字变换的四个函数，为主要函数。
              4.当移动数字，数组出现2048为赢，数组全不为0且不是2048为输。
由于本游戏主要的逻辑细节在四个平移函数里，所以我以右移为例说明一下。。。
①向右移动时，看到的是同一行数字的变化，从右边起相同的数字合并到右边；
②若在移动时有0元素，则忽略掉它，数字不会被0间隔。
所以在二维数组中就是同一行中相邻元素是否相等，相等就合并到一侧元素。
具体讲，当前元素不为0时，如果相邻元素不为0，若相等就合并到当前元素。
            当前元素为0时，如果相邻元素不为0，就合并到当前元素中。
以下是代码实现：
 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
#include 
#include 
#include 
#include 
#include 
#include 
#define row 4
#define col 4

//生成随机数
int RandNum()
{
    srand(time(NULL));//利用时间随机性作随机种子
    int num = rand() % 5; 
    if(num == 0 || num == 1 || num == 2 || num == 3)
    {
        return 2;
    }
    else
    {
        return 4;
    }
}

void Initial(int *arr) //初始化二维数组
{
    srand(time(NULL));
    int pos = rand() % (row * col);
    int poss = rand() % (row * col);
    arr[pos] = 2;
    arr[(pos + 5) % (row * col)] = RandNum();
}

void Rands(int *arr) //随机位置生成随机数2或4
{
    srand(time(NULL));
    int pos = rand() % (row * col);
    while(arr[pos] != 0)
    {
        pos = (pos + 1) % (row * col);
    }
    arr[pos] = RandNum();
}

int MoveLeft(int arr[row][col])  // 向左移动
{
    int flag = -1; // 变量标志是否移动了
    for(int i = 0; i < row; i++)
    {
        for(int j = 0; j < col-1; j++)
        {
            if(arr[i][j] != 0)
            {
                int k = j + 1;
                while(k < col)
                {
                    if(arr[i][k] !=  0)
                    {
                        if(arr[i][j] == arr[i][k])
                        {
                            flag = 0;
                            arr[i][j] += arr[i][k];
                            arr[i][k] = 0;
                        }
                        break;
                    }
                    k++;
                }
            }
        }
    }

for(int i = 0; i < row; i++)
    {
        for(int j = 0; j < col - 1; j++)
        {

if(arr[i][j] == 0)
            {
                int k = j + 1;
                while(k < col)
                {
                    if(arr[i][k] != 0)
                    {
                        flag = 0;
                        arr[i][j] = arr[i][k];
                        arr[i][k] = 0;
                        k = col;
                    }
                    k++;
                }
            }
        }
    }

if(flag == 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int MoveUp(int arr[row][col])  //向上移动
{
    int flag = -1;
    for(int j = 0; j < row; j++)
    {
        for(int i = 0; i < col-1; i++)
        {
            if(arr[i][j] != 0)
            {
                int k = i + 1;
                while(k < row)
                {
                    if(arr[k][j] != 0)
                    {
                        if(arr[i][j] == arr[k][j])
                        {
                            flag = 0;
                            arr[i][j] += arr[k][j];
                            arr[k][i] = 0;

}
                        break;
                    }
                    k++;
                }
            }
        }
    }

for(int j = 0; j < col; j++)
    {
        for(int i = 0; i < row - 1; i++)
        {

if(arr[i][j] == 0)
            {
                int k = i + 1;
                while(k < row)
                {
                    if(arr[i][j] != arr[k][j])
                    {
                        flag = 0;
                        arr[i][j] += arr[k][j];
                        arr[k][j] = 0;
                        k = row;
                    }
                    k++;
                }
            }
        }
    }

if(flag == 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int MoveRight(int arr[row][col])  //向右移动
{
    int flag = -1;
    for(int i = 0; i < row; i++)
    {
        for(int j = col - 1; j >= 1; j--)
        {
            if(arr[i][j] != 0)
            {
                int k = j - 1;
                while(k >= 0)
                {
                    if(arr[i][k] != 0)
                    {
                        if(arr[i][j] == arr[i][k])
                        {
                            flag = 0;
                            arr[i][j] += arr[i][k];
                            arr[i][k] = 0;

}
                        break;
              &nnbsp;     }
                    k--;
                }
            }
        }
    }

for(int i = 0; i < row; i++)
    {
        for(int j = col - 1; j >= 1; j--)
        {
            if(arr[i][j] == 0)
            {
                int k = j - 1;
                while(k >= 0)
                {
                    if(arr[i][j] != arr[i][k])
                    {
                        flag = 0;
                        arr[i][j] = arr[i][k];
                        arr[i][k] = 0;
                        k = 0;
                    }
                    k--;
                }
            }
        }
    }

if(flag == 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int MoveDown(int arr[row][col])  //向下移动
{
    int flag = -1;
    for(int j = 0; j < col; j++)
    {
        for(int i = row - 1; i >= 1; i--)
        {
            if(arr[i][j] != 0)
            {
                int k = i - 1;
                while(k >= 0)
                {
                    if(arr[k][j] != 0)
                    {
                        if(arr[i][j] == arr[k][j])
                        {
                            flag = 0;
                            arr[i][j] += arr[k][j];
                            arr[k][j] = 0;

}
                        break;
                    }
                    k--;
                }
            }
        }
    }

for(int j = 0; j < col; j++)
    {
        for(int i = row - 1; i >= 1; i--)
        {
            {
                if(arr[i][j] == 0)
                {
                    int k = i - 1;
                    while(k >= 0)
                    {
                        if(arr[k][j] != 0)
                        {
                            flag = 0;
                            arr[i][j] = arr[k][j];
                            arr[k][j] = 0;
                            k = 0;
                        }
                        k--;
                    }
                }
            }
        }
    }

if(flag == 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

void display(int arr[row][col]) //打印数组
{
    for(int i = 0; i < row; i++)
    {
        for(int j = 0; j < col; j++)
        {
            printf("]", arr[i][j]);
        }
        printf("\n");
    }
}

bool Contain2048(int arr[row][col]) )//判断游戏是否胜利

{
    for(int i = 0; i < row; i++)
    {
        for(int j = 0; j < col; j++)
        {
            if(arr[i][j] == 2048)
            {
                printf("You have a victory!");
                return true;
            }
        }
    }
    return false;
}

bool GameOver(int arr[row][col]) //判断游戏是否失败
{
    for(int i = 0; i < row; i++)
    {
        for(int j = 0; j < col; j++)
        {
            if(arr[i][j] == 0)
            {
                return false;
            }
        }
    }
    return true;
}

void Menu(int arr[row][col]) //主菜单
{
    int ch = _getch();//控制台获取字符
    while(1)
    {
        switch(ch = _getch())
        {
        case  72:
        {
            if(MoveUp(arr))
            {
                Rands(&arr[0][0]);
            }
            system("cls");
            display(arr);
            if(Contain2048(arr))
            {
                return ;
            }
            break;
        }
        case 80:
        {
            if(MoveDown(arr))
            {
                Rands(&arr[0][0]);
            }
            system("cls");
            display(arr);
            if(Contain2048(arr))
            {
                return ;
            }
            break;
        }
        case 75:
        {
            if(MoveLeft(arr))
            {
                Rands(&arr[0][0]);
            }
            system("cls");
            display(arr);
            if(Contain2048(arr))
            {
                return ;
            }
            break;
        }
        case 77:
        {
            if(MoveRight(arr))
            {
                Rands(&arr[0][0]);
            }
            system("cls");
            display(arr);
            if(Contain2048(arr))
            {
                return ;
            }
            break;
        }
        default:
            break;
        }
        if(GameOver(arr))
        {
            printf("Game Over!!!\n");
            return;
        }
    }
}

int main()
{
    int arr[row][col] = {0};
    Initial(&arr[0][0]);
    display(arr);
    Menu(arr);
    return 0;
}

对于此游戏的代码实现过程有不清楚的或者不同意见，可以在评论私聊我哦。\(^o^)/~谢谢大家

小游戏---2048相关推荐

  1. html+css+javascript实现小游戏2048（详解，附源代码）

    html+css+javascript实现小游戏2048(详解,附源代码) 1.上下左右的移动原理相同,这里只详细说明向上移动的方法 2.这里的上下左右由wasd四个键控制 3-小方块空的意思就是没数 ...

  2. 前端小游戏2048（一步步详解附带源代码，源码上传到csdn,可以免费下载）

    2048小游戏 2048是前端开发必经的一个小游戏,2048小游戏包含了HTML,CSS和JavaScript. 简介 <2048>,是一款益智小游戏,这款游戏是由年仅19岁的意大利程序员 ...

  3. 【python教程入门学习】Python实例：小游戏2048

    本节教程通过 2048 的小游戏快速.完整地呈现了使用 Python 语言编程的过程,将之前介绍的内容有机地结合在了一起 .2048是一款流行于手机.平板等终端设备上的益智小游戏,最早于 2014 年 ...

  4. Cocos Creator小游戏-2048（PC、安卓、H5）益智类 项目展示+完整项目源码

    游戏录像 Cocos Creator小游戏-2048 游戏玩法 在棋盘上,每次会增加一个小动物,你可以选择四个方向滑动,然后小动物会按方向移动,遇到相同的小动物就会合并,看谁合并的最多. 功能 1.初 ...

  5. c语言2048项目报告,c语言----项目_小游戏2048

    2048 小游戏 主要是针对逻辑思维的一个训练. 主要学习方面:1.随机数产生的概率.2.行与列在进行移动的时候几种情况.3.messagebox的使用 #include #include #incl ...

  6. CSS小游戏2048—简单小游戏编程有手就行~会玩？你会写吗？

    简单实现2048小游戏 想实现2048游戏书写代码时可以分为三个步骤 一.HTML部分 先书写HTML把游戏结构搭建出来 <!DOCTYPE html> <html lang=&qu ...

  7. C语言小游戏: 2048.c

    概要:2048.c是一个C语言编写的2048游戏,本文将详细分析它的源码和实现.C语言是一种经典实用的编程语言,本身也不复杂,但是学会C语言和能够编写实用的程序还是有一道鸿沟的.本文试图通过一个例子展 ...

  8. 经典小游戏2048 代码教学

    2048的玩法: 使用方向键移动方块,两个数字相同的方块撞在一起后,将会合并为一个数字是原来两倍的新方块! 在手机上可以滑动屏幕来移动方块! html代码部分 <!DOCTYPE html> ...

  9. 小游戏2048设计思路超简单

    2048作为一个经典的小游戏,对于C语言的逻辑练习是一个比较好的案例了,看似很复杂,但是如果掌握了设计思路,那么就不会觉得难了,而且会了这个之后对今后编程的也会有很大的帮助. 先分析游戏逻辑,游戏其实 ...

  10. html5 | 前端小游戏 | 2048 益智游戏

    游戏截图 游戏说明 2048网页版游戏,移动方向键,让相同数字组合争取获得最高分数. 项目结构 iindex.html代码 <!DOCTYPE html> <html>< ...

最新文章

  1. 大数据分析常用去重算法分析『HyperLogLog 篇』
  2. python闭包锁住女神的心
  3. 全球及中国模具激光焊接机行业供需分析与投资战略研究报告2021-2027年版
  4. Coursera吴恩达《神经网络与深度学习》课程笔记（2）-- 神经网络基础之逻辑回归
  5. Vue.js的虚拟dom
  6. Spring源码之ApplicationContext(四)功能补充
  7. 【内购篇】5 分钟教你成为会赚钱的独立开发者
  8. 架构模式: API网关
  9. 冰点还原精灵如何卸载
  10. 麦克风阵列语音增强（二）
  11. 如何训练神经网络的参数?,神经网络的参数计算
  12. Nowcoder专项练习：Linux（二）
  13. 安科瑞导轨表DDS/DTS/DTZ的功能特点
  14. 如何用快搭低代码平台搭建CRM、MES等系统
  15. 国际会计准则IAS 和 IFRS
  16. Latex学习以及IEEE论文投稿Latex排版经历
  17. 排针排母连接器的介绍
  18. 动态规划（pta例题）
  19. shell 编程四剑客简介 find sed grep awk(微信公众号摘抄）
  20. go 二维码解析推荐gozxing

热门文章

  1. win10c语言关机,技术员win10系统如何利用Shutdown.exe程序定时关机？
  2. JDK1.8.0_151的无限制强度加密策略文件变动
  3. html数据复制粘贴,如何复制和粘贴 HTML (HTML)
  4. R以逻辑回归为例介绍制作列线图（nomogram）的过程
  5. html 重置画布坐标系,H5中canvas的坐标系（画布初始）
  6. EXCEL2010数据挖掘插件 下载地址
  7. oracle权限培训,【必看】Oracle用户、权限、角色管理
  8. matlab 模拟风,【Matlab实现】风场仿真
  9. 电商系统中常见的 9 大坑，你踩过没？
  10. powershell中替换文件内容的方法