├── 2048.c
├── 2048_auto.c
└── README.md


/2048.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <stdlib.h>
  3 | #include <time.h>
  4 | 
  5 | int panel[4][4];
  6 | int score = 0;
  7 | 
  8 | /*
  9 |    a[0]1 2 3
 10 | i[0] 0 0 0 0
 11 | i[1] 0 0 0 0
 12 | i[2] 0 0 0 0
 13 | i[3] 0 0 0 0
 14 | 
 15 | 防止搞混
 16 | */
 17 | 
 18 | void init()
 19 | {
 20 |     srand(time(NULL)); //随机数种子
 21 |     for (int i = 0; i < 4; i++)
 22 |     {
 23 |         for (int a = 0; a < 4; a++)
 24 |         {
 25 |             panel[i][a] = 0;
 26 |         }
 27 |     }
 28 | }
 29 | 
 30 | int canMoveUp()
 31 | {
 32 |     for (int i = 0; i < 4; i++)
 33 |     {
 34 |         for (int a = 0; a < 4; a++)
 35 |         {
 36 |             if (i == 0 || panel[i][a] == 0) //第一行或者是0的位置
 37 |             {
 38 |                 continue;
 39 |             }
 40 |             if (panel[i - 1][a] == 0 || panel[i - 1][a] == panel[i][a]) //上方有空或者是可以组合
 41 |             {
 42 | 
 43 |                 return 1;
 44 |             }
 45 |         }
 46 |     }
 47 |     return 0;
 48 | }
 49 | 
 50 | void moveUp()
 51 | {
 52 |     while (canMoveUp()) //一步一步移动，移动到不能动为止
 53 |     {
 54 |         for (int i = 0; i < 4; i++)
 55 |         {
 56 |             for (int a = 0; a < 4; a++)
 57 |             {
 58 |                 if (i == 0 || panel[i][a] == 0)
 59 |                 {
 60 |                     continue;
 61 |                 }
 62 |                 if (panel[i - 1][a] == 0) //上方有空
 63 |                 {
 64 |                     panel[i - 1][a] = panel[i][a];
 65 |                     panel[i][a] = 0;
 66 |                     continue;
 67 |                 }
 68 |                 if (panel[i - 1][a] == panel[i][a]) //可以组合
 69 |                 {
 70 |                     score += panel[i][a] * 2;
 71 |                     panel[i - 1][a] = panel[i][a] * 2;
 72 |                     panel[i][a] = 0;
 73 |                 }
 74 |             }
 75 |         }
 76 |     }
 77 | }
 78 | 
 79 | int canMoveDown()
 80 | {
 81 |     for (int i = 0; i < 4; i++)
 82 |     {
 83 |         for (int a = 0; a < 4; a++)
 84 |         {
 85 |             if (i == 3 || panel[i][a] == 0) //第一行或者是0的位置
 86 |             {
 87 |                 continue;
 88 |             }
 89 |             if (panel[i + 1][a] == 0 || panel[i + 1][a] == panel[i][a]) //上方有空或者是可以组合
 90 |             {
 91 | 
 92 |                 return 1;
 93 |             }
 94 |         }
 95 |     }
 96 |     return 0;
 97 | }
 98 | 
 99 | int moveDown()
100 | {
101 |     while (canMoveDown())
102 |     {
103 |         for (int i = 0; i < 4; i++)
104 |         {
105 |             for (int a = 0; a < 4; a++)
106 |             {
107 |                 if (i == 3 || panel[i][a] == 0)
108 |                 {
109 |                     continue;
110 |                 }
111 |                 if (panel[i + 1][a] == 0)
112 |                 {
113 |                     panel[i + 1][a] = panel[i][a];
114 |                     panel[i][a] = 0;
115 |                     continue;
116 |                 }
117 |                 if (panel[i + 1][a] == panel[i][a])
118 |                 {
119 |                     score += panel[i][a] * 2;
120 |                     panel[i + 1][a] = panel[i][a] * 2;
121 |                     panel[i][a] = 0;
122 |                 }
123 |             }
124 |         }
125 |     }
126 | }
127 | int canMoveLeft()
128 | {
129 |     for (int i = 0; i < 4; i++)
130 |     {
131 |         for (int a = 0; a < 4; a++)
132 |         {
133 |             if (a == 0 || panel[i][a] == 0)
134 |             {
135 |                 continue;
136 |             }
137 |             if (panel[i][a - 1] == 0 || panel[i][a - 1] == panel[i][a])
138 |             {
139 |                 return 1;
140 |             }
141 |         }
142 |     }
143 |     return 0;
144 | }
145 | void moveLeft()
146 | {
147 | 
148 |     while (canMoveLeft()) //一步一步移动，移动到不能动为止
149 |     {
150 |         for (int i = 0; i < 4; i++)
151 |         {
152 |             for (int a = 0; a < 4; a++)
153 |             {
154 |                 if (a == 0 || panel[i][a] == 0)
155 |                 {
156 |                     continue;
157 |                 }
158 |                 if (panel[i][a - 1] == 0)
159 |                 {
160 |                     panel[i][a - 1] = panel[i][a];
161 |                     panel[i][a] = 0;
162 |                     continue;
163 |                 }
164 |                 if (panel[i][a - 1] == panel[i][a]) //可以组合
165 |                 {
166 |                     score += panel[i][a] * 2;
167 |                     panel[i][a - 1] = panel[i][a] * 2;
168 |                     panel[i][a] = 0;
169 |                 }
170 |             }
171 |         }
172 |     }
173 | }
174 | 
175 | int canMoveRight()
176 | {
177 |     for (int i = 0; i < 4; i++)
178 |     {
179 |         for (int a = 0; a < 4; a++)
180 |         {
181 |             if (a == 3 || panel[i][a] == 0)
182 |             {
183 |                 continue;
184 |             }
185 |             if (panel[i][a + 1] == 0 || panel[i][a + 1] == panel[i][a])
186 |             {
187 | 
188 |                 return 1;
189 |             }
190 |         }
191 |     }
192 |     return 0;
193 | }
194 | void moveRight()
195 | {
196 | 
197 |     while (canMoveRight()) //一步一步移动，移动到不能动为止
198 |     {
199 |         for (int i = 0; i < 4; i++)
200 |         {
201 |             for (int a = 0; a < 4; a++)
202 |             {
203 |                 if (a == 3 || panel[i][a] == 0)
204 |                 {
205 |                     continue;
206 |                 }
207 |                 if (panel[i][a + 1] == 0)
208 |                 {
209 |                     panel[i][a + 1] = panel[i][a];
210 |                     panel[i][a] = 0;
211 |                     continue;
212 |                 }
213 |                 if (panel[i][a + 1] == panel[i][a]) //可以组合
214 |                 {
215 |                     score += panel[i][a] * 2;
216 |                     panel[i][a + 1] = panel[i][a] * 2;
217 |                     panel[i][a] = 0;
218 |                 }
219 |             }
220 |         }
221 |     }
222 | }
223 | 
224 | int spawnNewBlock()
225 | { //每一回合生成新的块
226 |     int i, a;
227 |     int haveBlank = 0;
228 |     for (int i = 0; i < 4; i++)
229 |     {
230 |         for (int a = 0; a < 4; a++)
231 |         {
232 |             if (panel[i][a] == 0)
233 |             {
234 |                 haveBlank = 1;
235 |             }
236 |         }
237 |     }
238 |     if (haveBlank == 0)
239 |     {
240 |         return 0; //没有空位了，游戏结束
241 |     }
242 | 
243 |     do
244 |     {
245 |         i = rand() % 4; //0-3随机数
246 |         a = rand() % 4;
247 |         // printf("%d %d \n",i,a);
248 |     } while (panel[i][a] != 0); //找到一个空位
249 |     panel[i][a] = 2;
250 |     return 1;
251 | }
252 | 
253 | void printNumber(int number)
254 | {
255 |     int color;
256 |     switch (number)
257 |     {
258 | 
259 |     case 2:
260 |         color = 32;
261 |         break;
262 |     case 4:
263 |         color = 33;
264 |         break;
265 |     case 8:
266 |         color = 31;
267 |         break;
268 |     case 16:
269 |         color = 34;
270 |         break;
271 |     case 32:
272 |         color = 35;
273 |         break;
274 |     case 64:
275 |         color = 36;
276 |         break;
277 |     case 128:
278 |         color = 31;
279 |         break;
280 |     case 256:
281 |         color = 32;
282 |         break;
283 |     case 512:
284 |         color = 33;
285 |         break;
286 |     case 1024:
287 |         color = 34;
288 |         break;
289 |     case 2048:
290 |         color = 35;
291 |         break;
292 |     case 0:
293 |     default:
294 |         color = 37;
295 |         break;
296 |     }
297 |     printf("\033[%d;1m %5d\033[0m", color, number);
298 | }
299 | 
300 | void printPanel()
301 | {
302 |     system("cls"); // 清除屏幕
303 |     printf("Press WASD to move\n");
304 |     for (int i = 0; i < 4; i++)
305 |     {
306 |         for (int a = 0; a < 4; a++)
307 |         {
308 |             printNumber(panel[i][a]); // 格式输出
309 |         }
310 |         printf("\n\n");
311 |     }
312 |     printf("Score:%d \n", score);
313 | }
314 | 
315 | void play()
316 | {
317 |     char action;
318 |     int re = scanf("%c", &action);
319 |     if (re == 0)
320 |     {
321 |         printf("Input error ,try again \n");
322 |         play();
323 |         return;
324 |     }
325 |     switch (action)
326 |     {
327 |     case 'w':
328 |         moveUp();
329 |         break;
330 |     case 's':
331 |         moveDown();
332 |         break;
333 |     case 'a':
334 |         moveLeft();
335 |         break;
336 |     case 'd':
337 |         moveRight();
338 |         break;
339 |     default:
340 | 
341 |         play();
342 |         return;
343 |     }
344 | }
345 | 
346 | int main(int argc, char const *argv[])
347 | {
348 |     init();
349 | 
350 |     while (spawnNewBlock())
351 |     {
352 |         printPanel();
353 |         play();
354 |     }
355 |     printf("Game Over!\n");
356 |     printf("Your score: %d\n", score);
357 |     system("pause");
358 |     return 0;
359 | }
360 | 


--------------------------------------------------------------------------------
/2048_auto.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <stdlib.h>
  3 | #include <time.h>
  4 | #include <Windows.h>
  5 | 
  6 | int panel[4][4];
  7 | int score = 0;
  8 | 
  9 | /*
 10 |    a[0]1 2 3
 11 | i[0] 0 0 0 0
 12 | i[1] 0 0 0 0
 13 | i[2] 0 0 0 0
 14 | i[3] 0 0 0 0
 15 | 
 16 | 防止搞混
 17 | 
 18 | 自动玩2048小游戏，还没写ai
 19 | */
 20 | 
 21 | void init()
 22 | {
 23 |     srand(time(NULL)); //随机数种子
 24 |     for (int i = 0; i < 4; i++)
 25 |     {
 26 |         for (int a = 0; a < 4; a++)
 27 |         {
 28 |             panel[i][a] = 0;
 29 |         }
 30 |     }
 31 | }
 32 | 
 33 | int canMoveUp()
 34 | {
 35 |     for (int i = 0; i < 4; i++)
 36 |     {
 37 |         for (int a = 0; a < 4; a++)
 38 |         {
 39 |             if (i == 0 || panel[i][a] == 0) //第一行或者是0的位置
 40 |             {
 41 |                 continue;
 42 |             }
 43 |             if (panel[i - 1][a] == 0 || panel[i - 1][a] == panel[i][a]) //上方有空或者是可以组合
 44 |             {
 45 | 
 46 |                 return 1;
 47 |             }
 48 |         }
 49 |     }
 50 |     return 0;
 51 | }
 52 | 
 53 | void moveUp()
 54 | {
 55 |     while (canMoveUp()) //一步一步移动，移动到不能动为止
 56 |     {
 57 |         for (int i = 0; i < 4; i++)
 58 |         {
 59 |             for (int a = 0; a < 4; a++)
 60 |             {
 61 |                 if (i == 0 || panel[i][a] == 0)
 62 |                 {
 63 |                     continue;
 64 |                 }
 65 |                 if (panel[i - 1][a] == 0) //上方有空
 66 |                 {
 67 |                     panel[i - 1][a] = panel[i][a];
 68 |                     panel[i][a] = 0;
 69 |                     continue;
 70 |                 }
 71 |                 if (panel[i - 1][a] == panel[i][a]) //可以组合
 72 |                 {
 73 |                     score += panel[i][a] * 2;
 74 |                     panel[i - 1][a] = panel[i][a] * 2;
 75 |                     panel[i][a] = 0;
 76 |                 }
 77 |             }
 78 |         }
 79 |     }
 80 | }
 81 | 
 82 | int canMoveDown()
 83 | {
 84 |     for (int i = 0; i < 4; i++)
 85 |     {
 86 |         for (int a = 0; a < 4; a++)
 87 |         {
 88 |             if (i == 3 || panel[i][a] == 0) //第一行或者是0的位置
 89 |             {
 90 |                 continue;
 91 |             }
 92 |             if (panel[i + 1][a] == 0 || panel[i + 1][a] == panel[i][a]) //上方有空或者是可以组合
 93 |             {
 94 | 
 95 |                 return 1;
 96 |             }
 97 |         }
 98 |     }
 99 |     return 0;
100 | }
101 | 
102 | int moveDown()
103 | {
104 |     while (canMoveDown())
105 |     {
106 |         for (int i = 0; i < 4; i++)
107 |         {
108 |             for (int a = 0; a < 4; a++)
109 |             {
110 |                 if (i == 3 || panel[i][a] == 0)
111 |                 {
112 |                     continue;
113 |                 }
114 |                 if (panel[i + 1][a] == 0)
115 |                 {
116 |                     panel[i + 1][a] = panel[i][a];
117 |                     panel[i][a] = 0;
118 |                     continue;
119 |                 }
120 |                 if (panel[i + 1][a] == panel[i][a])
121 |                 {
122 |                     score += panel[i][a] * 2;
123 |                     panel[i + 1][a] = panel[i][a] * 2;
124 |                     panel[i][a] = 0;
125 |                 }
126 |             }
127 |         }
128 |     }
129 | }
130 | int canMoveLeft()
131 | {
132 |     for (int i = 0; i < 4; i++)
133 |     {
134 |         for (int a = 0; a < 4; a++)
135 |         {
136 |             if (a == 0 || panel[i][a] == 0)
137 |             {
138 |                 continue;
139 |             }
140 |             if (panel[i][a - 1] == 0 || panel[i][a - 1] == panel[i][a])
141 |             {
142 |                 return 1;
143 |             }
144 |         }
145 |     }
146 |     return 0;
147 | }
148 | void moveLeft()
149 | {
150 | 
151 |     while (canMoveLeft()) //一步一步移动，移动到不能动为止
152 |     {
153 |         for (int i = 0; i < 4; i++)
154 |         {
155 |             for (int a = 0; a < 4; a++)
156 |             {
157 |                 if (a == 0 || panel[i][a] == 0)
158 |                 {
159 |                     continue;
160 |                 }
161 |                 if (panel[i][a - 1] == 0)
162 |                 {
163 |                     panel[i][a - 1] = panel[i][a];
164 |                     panel[i][a] = 0;
165 |                     continue;
166 |                 }
167 |                 if (panel[i][a - 1] == panel[i][a]) //可以组合
168 |                 {
169 |                     score += panel[i][a] * 2;
170 |                     panel[i][a - 1] = panel[i][a] * 2;
171 |                     panel[i][a] = 0;
172 |                 }
173 |             }
174 |         }
175 |     }
176 | }
177 | 
178 | int canMoveRight()
179 | {
180 |     for (int i = 0; i < 4; i++)
181 |     {
182 |         for (int a = 0; a < 4; a++)
183 |         {
184 |             if (a == 3 || panel[i][a] == 0)
185 |             {
186 |                 continue;
187 |             }
188 |             if (panel[i][a + 1] == 0 || panel[i][a + 1] == panel[i][a])
189 |             {
190 | 
191 |                 return 1;
192 |             }
193 |         }
194 |     }
195 |     return 0;
196 | }
197 | void moveRight()
198 | {
199 | 
200 |     while (canMoveRight()) //一步一步移动，移动到不能动为止
201 |     {
202 |         for (int i = 0; i < 4; i++)
203 |         {
204 |             for (int a = 0; a < 4; a++)
205 |             {
206 |                 if (a == 3 || panel[i][a] == 0)
207 |                 {
208 |                     continue;
209 |                 }
210 |                 if (panel[i][a + 1] == 0)
211 |                 {
212 |                     panel[i][a + 1] = panel[i][a];
213 |                     panel[i][a] = 0;
214 |                     continue;
215 |                 }
216 |                 if (panel[i][a + 1] == panel[i][a]) //可以组合
217 |                 {
218 |                     score += panel[i][a] * 2;
219 |                     panel[i][a + 1] = panel[i][a] * 2;
220 |                     panel[i][a] = 0;
221 |                 }
222 |             }
223 |         }
224 |     }
225 | }
226 | int weightMoveUp()
227 | {
228 |     int weight = 0;
229 |     for (int i = 0; i < 4; i++)
230 |     {
231 |         for (int a = 0; a < 4; a++)
232 |         {
233 |             if (i == 0 || panel[i][a] == 0) //第一行或者是0的位置
234 |             {
235 |                 continue;
236 |             }
237 |             if (panel[i - 1][a] == panel[i][a]) //上方可以组合，权重最高
238 |             {
239 |                 weight += panel[i][a] * 2;
240 |                 continue;
241 |             }
242 | 
243 |             if (panel[i - 1][a] == 0)
244 |             {
245 |                 weight++;
246 |             }
247 |         }
248 |     }
249 |     return weight;
250 | }
251 | 
252 | int weightMoveRight()
253 | {
254 |     if (canMoveRight() != 1)
255 |     {
256 |         return 0;
257 |     }
258 | 
259 |     int cache[4][4];
260 |     int cacheScore;
261 |     for (int i = 0; i < 4; i++)
262 |     {
263 |         for (int a = 0; a < 4; a++)
264 |         {
265 |             cache[i][a] = panel[i][a];
266 |         }
267 |     }
268 |     cacheScore = score;
269 |     moveRight();
270 |     int weight = weightMoveUp();
271 |     score = cacheScore;
272 |     for (int i = 0; i < 4; i++)
273 |     {
274 |         for (int a = 0; a < 4; a++)
275 |         {
276 |             panel[i][a] = cache[i][a];
277 |         }
278 |     }
279 |     return weight;
280 | }
281 | 
282 | int weightMoveLeft()
283 | {
284 |     if (canMoveLeft() != 1)
285 |     {
286 |         return 0;
287 |     }
288 |     int cache[4][4];
289 |     int cacheScore;
290 |     for (int i = 0; i < 4; i++)
291 |     {
292 |         for (int a = 0; a < 4; a++)
293 |         {
294 |             cache[i][a] = panel[i][a];
295 |         }
296 |     }
297 |     cacheScore = score;
298 |     moveLeft();
299 |     score = cacheScore;
300 |     int weight = weightMoveUp();
301 |     for (int i = 0; i < 4; i++)
302 |     {
303 |         for (int a = 0; a < 4; a++)
304 |         {
305 |             panel[i][a] = cache[i][a];
306 |         }
307 |     }
308 |     return weight;
309 | }
310 | 
311 | int spawnNewBlock()
312 | { //每一回合生成新的块
313 |     int i, a;
314 |     int haveBlank = 0;
315 |     for (int i = 0; i < 4; i++)
316 |     {
317 |         for (int a = 0; a < 4; a++)
318 |         {
319 |             if (panel[i][a] == 0)
320 |             {
321 |                 haveBlank = 1;
322 |             }
323 |         }
324 |     }
325 |     if (haveBlank == 0)
326 |     {
327 |         return 0; //没有空位了，游戏结束
328 |     }
329 | 
330 |     do
331 |     {
332 |         i = rand() % 4; //0-3随机数
333 |         a = rand() % 4;
334 |         // printf("%d %d \n",i,a);
335 |     } while (panel[i][a] != 0); //找到一个空位
336 |     panel[i][a] = 2;
337 |     return 1;
338 | }
339 | 
340 | void printNumber(int number)
341 | {
342 |     int color;
343 |     switch (number)
344 |     {
345 | 
346 |     case 2:
347 |         color = 32;
348 |         break;
349 |     case 4:
350 |         color = 33;
351 |         break;
352 |     case 8:
353 |         color = 31;
354 |         break;
355 |     case 16:
356 |         color = 34;
357 |         break;
358 |     case 32:
359 |         color = 35;
360 |         break;
361 |     case 64:
362 |         color = 36;
363 |         break;
364 |     case 128:
365 |         color = 31;
366 |         break;
367 |     case 256:
368 |         color = 32;
369 |         break;
370 |     case 512:
371 |         color = 33;
372 |         break;
373 |     case 1024:
374 |         color = 34;
375 |         break;
376 |     case 2048:
377 |         color = 35;
378 |         break;
379 |     case 0:
380 |     default:
381 |         color = 37;
382 |         break;
383 |     }
384 |     printf("\033[%d;1m %5d\033[0m", color, number);
385 | }
386 | 
387 | void printPanel()
388 | {
389 |     system("cls"); // 清除屏幕
390 |     printf("Wait moving !!!!\n");
391 |     for (int i = 0; i < 4; i++)
392 |     {
393 |         for (int a = 0; a < 4; a++)
394 |         {
395 |             printNumber(panel[i][a]); // 格式输出
396 |         }
397 |         printf("\n\n");
398 |     }
399 |     printf("Score:%d \n", score);
400 | }
401 | 
402 | int status = 1;
403 | void play()
404 | {
405 |     if (weightMoveUp() >= 8)
406 |     {
407 |         moveUp();
408 |         Sleep(50);
409 |         return;
410 |     }
411 |     int left = weightMoveLeft();
412 |     int right = weightMoveRight();
413 |     if (left >= 4 && left > right)
414 |     {
415 |         moveLeft();
416 |         Sleep(50);
417 |         return;
418 |     }
419 |     if (right >= 4 && right > left)
420 |     {
421 |         moveRight();
422 |         Sleep(50);
423 |         return;
424 |     }
425 | 
426 |     switch (status)
427 |     {
428 |     case 1:
429 |         moveUp();
430 |         break;
431 |     case 2:
432 |         moveRight();
433 |         break;
434 |     case 3:
435 |         moveUp();
436 |         break;
437 |     case 4:
438 |         moveLeft();
439 |         break;
440 |     default:
441 |         break;
442 |     }
443 |     status++;
444 |     if (status > 4)
445 |     {
446 |         status = 1;
447 |     }
448 |     Sleep(50);
449 | }
450 | 
451 | int main(int argc, char const *argv[])
452 | {
453 |     init();
454 | 
455 |     while (spawnNewBlock())
456 |     {
457 |         printPanel();
458 |         play();
459 |     }
460 |     printf("Game Over!\n");
461 |     printf("Your score: %d\n", score);
462 |     system("pause");
463 |     return 0;
464 | }
465 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # 2048-c
2 | 学习c语言随手写的2048小游戏，附带一个自动玩的ai
3 | 


--------------------------------------------------------------------------------