研究win16实现2048小游戏（基于windows1.03sdk+msc4.0）

健康快乐

刚开始学习Windows编程给自己找了个最难的环境286+dos3.33+Windows1.03
很多win32程序设计的思路在win16时代都能找到萌芽！！！这并不割裂！！！！
但是还是一如既往的难受单单R&K语法我就研究了半天！！！！！
简单的出版本2048：

1. /* 2048.c - Windows 1.03 Edition~ */
   
2. /* 基于Microsoft C 5.0 + Windows SDK 1.03 */
   
3. /* 基于K&R C style - 夏媛媛手敲~ */
   
4. 
   
5. #include <windows.h>
   
6. #include <stdlib.h>
   
7. #include <stdio.h>    /* sprintf */
   
8. #include <string.h>   /* strlen */
   
9. #include "2048.h"     /* 资源ID定义（IDM_NEWGAME, IDM_HOWTOPLAY, IDM_ABOUT, IDSYS_ABOUT, DLG_ABOUT, DLG_HOWTOPLAY） */
   
10. 
    
11. void SaveGame();
    
12. int  LoadGame();
    
13. 
    
14. /* ======= 分数历史记录（二进制文件，防玩家修改） ======= */
    
15. typedef struct {
    
16.     int highscore;          /* 历史最高分 */
    
17.     int recent[5];          /* 最近 5 局分数（下标 0 为最新） */
    
18.     int count;              /* 实际记录局数（<=5） */
    
19. } ScoreHistory;
    
20. 
    
21. /* 分数历史文件操作（K&R 旧式声明，只写参数名） */
    
22. BOOL GetScoreHistory();
    
23. void SetScoreHistory();
    
24. void UpdateScoreHistory();
    
25. 
    
26. /* 分数板对话框过程（K&R 旧式声明） */
    
27. BOOL FAR PASCAL ScoreboardDlg();
    
28. 
    
29. #define BOARD_SIZE 4
    
30. #define CELL_W     55
    
31. #define CELL_H     55
    
32. #define MARGIN     8
    
33. 
    
34. /* 全局数据段变量 */
    
35. int  board[BOARD_SIZE][BOARD_SIZE];
    
36. int  score;
    
37. int  game_over;
    
38. int g_bDirty = 0; /* 新增：脏标记，0=状态与存档一致，1=有未保存改动 */
    
39. int g_bPlayerMoved = 0;  /* 玩家是否进行过主动操作 */
    
40. HBRUSH hBrush, hOldBrush;
    
41. HWND hWndMain;
    
42. HANDLE hInst;                  /* 实例句柄 */
    
43. FARPROC lpfnAboutDlg;          /* About 对话框过程实例地址 */
    
44. FARPROC lpfnHowToPlayDlg;      /* HowToPlay 对话框过程实例地址 */
    
45. FARPROC lpfnScoreboardDlg;      /* 分数板对话框过程实例地址 */
    
46. 
    
47. /* GDI对象缓存 */
    
48. HBRUSH hBrushes[13];   /* 0=空白,1=2,2=4,3=8...12=2048+ */
    
49. HPEN   hPenBlack;
    
50. HPEN   hPenWhite;
    
51. RECT   rcGame;   /* 游戏区域 */
    
52. 
    
53. /* K&R 函数前置声明 */
    
54. void InitGame();
    
55. void AddRandomTile();
    
56. int  MoveLeft();
    
57. int  MoveRight();
    
58. int  MoveUp();
    
59. int  MoveDown();
    
60. int  CanMove();
    
61. void DrawBoard();
    
62. void DrawCell();
    
63. void InitGDI();
    
64. void CleanupGDI();
    
65. int  ValueToIndex();
    
66. long FAR PASCAL WndProc();
    
67. BOOL FAR PASCAL AboutDlg();
    
68. BOOL FAR PASCAL HowToPlayDlg();
    
69. 
    
70. /* ============================================================
    
71.    窗口过程
    
72.    ============================================================ */
    
73. long FAR PASCAL WndProc(hWnd, message, wParam, lParam)
    
74. HWND     hWnd;
    
75. unsigned message;
    
76. WORD     wParam;
    
77. LONG     lParam;
    
78. {
    
79.     PAINTSTRUCT ps;
    
80.     HDC         hDC;
    
81.     RECT        rect;
    
82.     char        buf[64];
    
83.     int         i, j;
    
84. 
    
85.     switch (message) {
    
86. 
    
87.         case WM_CREATE:
    
88.             hWndMain = hWnd;
    
89.             InitGame();
    
90.             InitGDI();
    
91.             rcGame.left   = 0;
    
92.             rcGame.top    = 0;
    
93.             rcGame.right  = 280;
    
94.             rcGame.bottom = 320;
    
95.             break;
    
96. 
    
97.         case WM_PAINT:
    
98.             hDC = BeginPaint(hWnd, &ps);
    
99.             GetClientRect(hWnd, &rect);
    
100. 
     
101.             /* 刷白背景 */
     
102.             hBrush = GetStockObject(WHITE_BRUSH);
     
103.             hOldBrush = SelectObject(hDC, hBrush);
     
104.             PatBlt(hDC, rect.left, rect.top,
     
105.                    rect.right - rect.left,
     
106.                    rect.bottom - rect.top, PATCOPY);
     
107.             SelectObject(hDC, hOldBrush);
     
108. 
     
109.             SetBkMode(hDC, TRANSPARENT);
     
110.             SetTextColor(hDC, RGB(0, 0, 0));
     
111. 
     
112.             /* 标题栏 */
     
113.             sprintf(buf, "2048  Score: %d", score);
     
114.             TextOut(hDC, MARGIN, 4, buf, strlen(buf));
     
115. 
     
116.             if (game_over) {
     
117.                 TextOut(hDC, MARGIN, 20,
     
118.                         "GAME OVER - Press N for New Game", 32);
     
119.             } else {
     
120.                 TextOut(hDC, MARGIN, 20,
     
121.                         "Arrows: Move   N: New Game", 26);
     
122.             }
     
123. 
     
124.             DrawBoard(hDC);
     
125.             EndPaint(hWnd, &ps);
     
126.             break;
     
127. 
     
128.         case WM_KEYDOWN:
     
129.             if (game_over && wParam != 'N' && wParam != 'n')
     
130.                 break;
     
131. 
     
132.             switch (wParam) {
     
133.                 case VK_LEFT:
     
134.                     if (MoveLeft()) goto MOVED;
     
135.                     break;
     
136.                 case VK_RIGHT:
     
137.                     if (MoveRight()) goto MOVED;
     
138.                     break;
     
139.                 case VK_UP:
     
140.                     if (MoveUp()) goto MOVED;
     
141.                     break;
     
142.                 case VK_DOWN:
     
143.                     if (MoveDown()) goto MOVED;
     
144.                     break;
     
145.                 case 'N':
     
146.                 case 'n':
     
147.                         remove("2048.sav");
     
148.                         g_bPlayerMoved = 0;
     
149.                         InitGame();
     
150.                                         /* 修正：新游戏后，脏标记应为 1 */
     
151.                     g_bDirty = 1;
     
152.                     InvalidateRect(hWnd, &rcGame, FALSE);
     
153.                     break;
     
154.             }
     
155.             break;
     
156. 
     
157. MOVED:
     
158.             /* 如果玩家是第一次操作，删除旧的存档文件 */
     
159.                 if (!g_bPlayerMoved) {
     
160.                         remove("2048.sav");    /* 旧存档已无效 */
     
161.                         g_bPlayerMoved = 1;
     
162.                 }
     
163.                 AddRandomTile();
     
164.                         /* 修正：任何移动成功并添加了随机块，都应视为状态改变 */
     
165.             g_bDirty = 1;
     
166.                 if (!CanMove()){
     
167.                 game_over = 1;
     
168.                 /* 游戏结束 → 更新分数历史并弹出分数板 */
     
169.                 UpdateScoreHistory(score);
     
170.             DialogBox(hInst, MAKEINTRESOURCE(DLG_SCOREBOARD),
     
171.                       hWnd, lpfnScoreboardDlg);
     
172.             }
     
173.             InvalidateRect(hWnd, &rcGame, FALSE);
     
174.             break;
     
175. 
     
176.         /* 新增：处理菜单命令（Game、Help菜单） */
     
177.         case WM_COMMAND:
     
178.             switch (wParam) {
     
179.                 case IDM_NEWGAME:
     
180.                         remove("2048.sav");
     
181.                         g_bPlayerMoved = 0;
     
182.                         InitGame();
     
183.                         g_bDirty = 1;   /* 修正：新游戏后，脏标记应为 1 */
     
184.                     InvalidateRect(hWnd, &rcGame, FALSE);
     
185.                     break;
     
186.                 case IDM_SAVE:
     
187.             SaveGame();
     
188.             g_bDirty = 0;
     
189.             InvalidateRect(hWnd, &rcGame, FALSE);
     
190.             break;
     
191.                 case IDM_SCOREBOARD:
     
192.             /* 玩家随时查看分数板，当前分数来自全局变量 score */
     
193.             DialogBox(hInst, MAKEINTRESOURCE(DLG_SCOREBOARD),
     
194.                       hWnd, lpfnScoreboardDlg);
     
195.             break;
     
196.                 case IDM_HOWTOPLAY:
     
197.                     DialogBox(hInst, MAKEINTRESOURCE(DLG_HOWTOPLAY),
     
198.                               hWnd, lpfnHowToPlayDlg);
     
199.                     break;
     
200.                 case IDM_ABOUT:
     
201.                     DialogBox(hInst, MAKEINTRESOURCE(DLG_ABOUT),
     
202.                               hWnd, lpfnAboutDlg);
     
203.                     break;
     
204.                 default:
     
205.                     return DefWindowProc(hWnd, message, wParam, lParam);
     
206.             }
     
207.             break;
     
208. 
     
209.         /* 新增：处理系统菜单（左上角 About…） */
     
210.         case WM_SYSCOMMAND:
     
211.             if (wParam == IDSYS_ABOUT) {
     
212.                 DialogBox(hInst, MAKEINTRESOURCE(DLG_ABOUT),
     
213.                           hWnd, lpfnAboutDlg);
     
214.                 return 0;
     
215.             }
     
216.             /* 其他系统命令（最大化、最小化、移动、关闭等）必须交给默认处理 */
     
217.             return DefWindowProc(hWnd, message, wParam, lParam);
     
218. 
     
219.         case WM_DESTROY:
     
220.             /* ============================================================
     
221.                修正：退出时检查是否需要存档提醒
     
222.                设计思路：
     
223.                1. 如果游戏已经结束 (game_over == 1)，直接退出，不提醒。
     
224.                2. 如果游戏未结束，但有未保存的改动 (g_bDirty == 1)，则触发提醒。
     
225.                3. 如果游戏未结束且没有改动 (g_bDirty == 0)，说明用户已手动保存过，
     
226.                   直接退出，不打扰用户。
     
227.             ============================================================ */
     
228.             if (!game_over && g_bDirty && g_bPlayerMoved) {
     
229.                 /* 弹出可爱的英文提示框 */
     
230.                 if (MessageBox(hWnd,
     
231.             "Ooh! Meow ^v^ You haven't saved your game!",
     
232.             "Save Game?",
     
233.             MB_YESNO | MB_ICONQUESTION) == IDYES) {
     
234.                     /* 用户选择保存 */
     
235.                     SaveGame();
     
236.                     g_bDirty = 0;
     
237.                 }
     
238.             }
     
239.                         /* 清理GDI对象和实例地址 */
     
240.                         CleanupGDI();
     
241.             FreeProcInstance(lpfnAboutDlg);
     
242.             FreeProcInstance(lpfnHowToPlayDlg);
     
243.                 FreeProcInstance(lpfnScoreboardDlg);
     
244.             PostQuitMessage(0);
     
245.             break;
     
246. 
     
247.         default:
     
248.             return DefWindowProc(hWnd, message, wParam, lParam);
     
249.     }
     
250.     return 0L;
     
251. }
     
252. 
     
253. /* ============================================================
     
254.    WinMain - 程序入口
     
255.    ============================================================ */
     
256. int PASCAL WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
     
257. HANDLE hInstance;
     
258. HANDLE hPrevInstance;
     
259. LPSTR  lpCmdLine;
     
260. int    nCmdShow;
     
261. {
     
262.     MSG        msg;
     
263.     WNDCLASS   wc;
     
264.     HWND       hWnd;
     
265.     HMENU      hMenu;
     
266.     HMENU      hSysMenu;
     
267. 
     
268.     srand((unsigned)GetCurrentTime());
     
269. 
     
270.     if (!hPrevInstance) {
     
271.         wc.style         = CS_HREDRAW | CS_VREDRAW;
     
272.         wc.lpfnWndProc   = WndProc;
     
273.         wc.cbClsExtra    = 0;
     
274.         wc.cbWndExtra    = 0;
     
275.         wc.hInstance     = hInstance;
     
276.         wc.hIcon = LoadIcon(hInstance, (LPSTR)"AppIcon");
     
277.         wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
     
278.         wc.hbrBackground = GetStockObject(WHITE_BRUSH);
     
279.         wc.lpszMenuName  = NULL;
     
280.         wc.lpszClassName = "2048W103";
     
281. 
     
282.         if (!RegisterClass(&wc))
     
283.             return FALSE;
     
284.     }
     
285. 
     
286.     hInst = hInstance;
     
287. 
     
288.     /* 创建对话框过程的实例地址（必须在创建窗口前准备好） */
     
289.     lpfnAboutDlg = MakeProcInstance((FARPROC)AboutDlg, hInstance);
     
290.     lpfnHowToPlayDlg = MakeProcInstance((FARPROC)HowToPlayDlg, hInstance);
     
291.         lpfnScoreboardDlg = MakeProcInstance((FARPROC)ScoreboardDlg, hInstance);
     
292. 
     
293.     /* 加载菜单栏（资源名为 "GAME_MENU"，在 2048.rc 中定义） */
     
294.     hMenu = LoadMenu(hInstance, (LPSTR)"GAME_MENU");
     
295.     if (!hMenu) {
     
296.         MessageBox(NULL, "Menu load failed!", NULL, MB_OK);
     
297.         return FALSE;
     
298.     }
     
299. 
     
300.     /* Windows 1.03 兼容样式：WS_TILEDWINDOW（等同于 WS_TILED|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX） */
     
301.     /* CreateWindow 只传 10 个参数，无最后的 lpParam */
     
302.     hWnd = CreateWindow("2048W103",
     
303.                         "2048 - Windows 1.03",
     
304.                         WS_TILEDWINDOW,
     
305.                         10, 10, 280, 320,
     
306.                         NULL,
     
307.                         hMenu,
     
308.                         hInstance,
     
309.                         NULL);
     
310. 
     
311.     if (!hWnd)
     
312.         return FALSE;
     
313. 
     
314.     /* ============================================================
     
315.        修正：启动时检测并加载存档
     
316.        设计思路：
     
317.        1. 尝试加载存档。如果成功，游戏状态恢复，存档文件被立即删除。
     
318.        2. 如果加载失败（没有存档或文件损坏），则开始一个全新的游戏。
     
319.        3. 无论是加载成功还是开始新游戏，都设置脏标记 g_bDirty = 1，
     
320.           因为有新状态产生，应视为未保存。
     
321.     ============================================================ */
     
322.     if (LoadGame()) {
     
323.         /* 成功加载存档，存档文件已被 LoadGame 内部删除 */
     
324.         InvalidateRect(hWnd, &rcGame, FALSE);
     
325.         g_bDirty = 0;   /* 恢复后的状态，视为未保存的新状态 */
     
326.         g_bPlayerMoved = 0;     /* 加载存档不算玩家操作 */
     
327.     } else {
     
328.         /* 没有存档，开始新游戏 */
     
329.         InitGame();
     
330.         g_bDirty = 1;   /* 新游戏视为未保存 */
     
331.         g_bPlayerMoved = 0;     /* 无存档启动，自动新游戏，视为玩家“开始了一局” */
     
332.     }
     
333.        
     
334.         /* 在系统菜单（左上角）添加分隔线后追加 About… */
     
335.     /* 先获取系统菜单副本 */
     
336.     hSysMenu = GetSystemMenu(hWnd, FALSE);
     
337.     if (hSysMenu) {
     
338.         /* 添加分隔线（横杠） */
     
339.         ChangeMenu(hSysMenu, 0, (LPSTR)NULL, 0,
     
340.                    MF_APPEND | MF_SEPARATOR);
     
341.         /* 添加 "About..." 命令 */
     
342.         ChangeMenu(hSysMenu, 0, (LPSTR)"About...",
     
343.                    IDSYS_ABOUT, MF_APPEND | MF_STRING);
     
344.     }
     
345.        
     
346.     ShowWindow(hWnd, nCmdShow);
     
347.     UpdateWindow(hWnd);
     
348. 
     
349.     while (GetMessage(&msg, NULL, 0, 0)) {
     
350.         TranslateMessage(&msg);
     
351.         DispatchMessage(&msg);
     
352.     }
     
353. 
     
354.     return msg.wParam;
     
355. }
     
356. 
     
357. /* ============================================================
     
358.    游戏逻辑
     
359.    ============================================================ */
     
360. 
     
361. void InitGame()
     
362. {
     
363.     int i, j;
     
364.     for (i = 0; i < BOARD_SIZE; i++)
     
365.         for (j = 0; j < BOARD_SIZE; j++)
     
366.             board[i][j] = 0;
     
367. 
     
368.     score = 0;
     
369.     game_over = 0;
     
370. 
     
371.     AddRandomTile();
     
372.     AddRandomTile();
     
373. }
     
374. 
     
375. void AddRandomTile()
     
376. {
     
377.     int empty[BOARD_SIZE * BOARD_SIZE][2];
     
378.     int count, pos;
     
379.     int i, j;
     
380. 
     
381.     count = 0;
     
382.     for (i = 0; i < BOARD_SIZE; i++)
     
383.         for (j = 0; j < BOARD_SIZE; j++)
     
384.             if (board[i][j] == 0) {
     
385.                 empty[count][0] = i;
     
386.                 empty[count][1] = j;
     
387.                 count++;
     
388.             }
     
389. 
     
390.     if (count == 0) return;
     
391. 
     
392.     pos = rand() % count;
     
393.     i = empty[pos][0];
     
394.     j = empty[pos][1];
     
395.     board[i][j] = (rand() % 10 == 0) ? 4 : 2;
     
396. }
     
397. 
     
398. int MoveLeft()
     
399. {
     
400.     int moved;
     
401.     int i, j, k;
     
402. 
     
403.     moved = 0;
     
404. 
     
405.     for (i = 0; i < BOARD_SIZE; i++) {
     
406.         /* 压缩 */
     
407.         for (j = 0; j < BOARD_SIZE; j++) {
     
408.             if (board[i][j] == 0) {
     
409.                 for (k = j + 1; k < BOARD_SIZE; k++) {
     
410.                     if (board[i][k] != 0) {
     
411.                         board[i][j] = board[i][k];
     
412.                         board[i][k] = 0;
     
413.                         moved = 1;
     
414.                         break;
     
415.                     }
     
416.                 }
     
417.             }
     
418.         }
     
419. 
     
420.         /* 合并 */
     
421.         for (j = 0; j < BOARD_SIZE - 1; j++) {
     
422.             if (board[i][j] != 0 && board[i][j] == board[i][j+1]) {
     
423.                 board[i][j] *= 2;
     
424.                 score += board[i][j];
     
425.                 board[i][j+1] = 0;
     
426.                 moved = 1;
     
427.             }
     
428.         }
     
429. 
     
430.         /* 再压缩 */
     
431.         for (j = 0; j < BOARD_SIZE; j++) {
     
432.             if (board[i][j] == 0) {
     
433.                 for (k = j + 1; k < BOARD_SIZE; k++) {
     
434.                     if (board[i][k] != 0) {
     
435.                         board[i][j] = board[i][k];
     
436.                         board[i][k] = 0;
     
437.                         moved = 1;
     
438.                         break;
     
439.                     }
     
440.                 }
     
441.             }
     
442.         }
     
443.     }
     
444. 
     
445.     return moved;
     
446. }
     
447. 
     
448. int MoveRight()
     
449. {
     
450.     int moved;
     
451.     int i, j;
     
452.     int tmp;
     
453. 
     
454.     for (i = 0; i < BOARD_SIZE; i++)
     
455.         for (j = 0; j < BOARD_SIZE / 2; j++) {
     
456.             tmp = board[i][j];
     
457.             board[i][j] = board[i][BOARD_SIZE - 1 - j];
     
458.             board[i][BOARD_SIZE - 1 - j] = tmp;
     
459.         }
     
460. 
     
461.     moved = MoveLeft();
     
462. 
     
463.     for (i = 0; i < BOARD_SIZE; i++)
     
464.         for (j = 0; j < BOARD_SIZE / 2; j++) {
     
465.             tmp = board[i][j];
     
466.             board[i][j] = board[i][BOARD_SIZE - 1 - j];
     
467.             board[i][BOARD_SIZE - 1 - j] = tmp;
     
468.         }
     
469. 
     
470.     return moved;
     
471. }
     
472. 
     
473. int MoveUp()
     
474. {
     
475.     int moved;
     
476.     int i, j;
     
477.     int tmp;
     
478. 
     
479.     for (i = 0; i < BOARD_SIZE; i++)
     
480.         for (j = i + 1; j < BOARD_SIZE; j++) {
     
481.             tmp = board[i][j];
     
482.             board[i][j] = board[j][i];
     
483.             board[j][i] = tmp;
     
484.         }
     
485. 
     
486.     moved = MoveLeft();
     
487. 
     
488.     for (i = 0; i < BOARD_SIZE; i++)
     
489.         for (j = i + 1; j < BOARD_SIZE; j++) {
     
490.             tmp = board[i][j];
     
491.             board[i][j] = board[j][i];
     
492.             board[j][i] = tmp;
     
493.         }
     
494. 
     
495.     return moved;
     
496. }
     
497. 
     
498. int MoveDown()
     
499. {
     
500.     int moved;
     
501.     int i, j;
     
502.     int tmp;
     
503. 
     
504.     /* 转置 */
     
505.     for (i = 0; i < BOARD_SIZE; i++)
     
506.         for (j = i + 1; j < BOARD_SIZE; j++) {
     
507.             tmp = board[i][j];
     
508.             board[i][j] = board[j][i];
     
509.             board[j][i] = tmp;
     
510.         }
     
511. 
     
512.     /* 水平翻转 */
     
513.     for (i = 0; i < BOARD_SIZE; i++)
     
514.         for (j = 0; j < BOARD_SIZE / 2; j++) {
     
515.             tmp = board[i][j];
     
516.             board[i][j] = board[i][BOARD_SIZE - 1 - j];
     
517.             board[i][BOARD_SIZE - 1 - j] = tmp;
     
518.         }
     
519. 
     
520.     moved = MoveLeft();
     
521. 
     
522.     /* 翻转回来 */
     
523.     for (i = 0; i < BOARD_SIZE; i++)
     
524.         for (j = 0; j < BOARD_SIZE / 2; j++) {
     
525.             tmp = board[i][j];
     
526.             board[i][j] = board[i][BOARD_SIZE - 1 - j];
     
527.             board[i][BOARD_SIZE - 1 - j] = tmp;
     
528.         }
     
529. 
     
530.     /* 转置回来 */
     
531.     for (i = 0; i < BOARD_SIZE; i++)
     
532.         for (j = i + 1; j < BOARD_SIZE; j++) {
     
533.             tmp = board[i][j];
     
534.             board[i][j] = board[j][i];
     
535.             board[j][i] = tmp;
     
536.         }
     
537. 
     
538.     return moved;
     
539. }
     
540. 
     
541. int CanMove()
     
542. {
     
543.     int i, j;
     
544. 
     
545.     for (i = 0; i < BOARD_SIZE; i++)
     
546.         for (j = 0; j < BOARD_SIZE; j++)
     
547.             if (board[i][j] == 0)
     
548.                 return 1;
     
549. 
     
550.     for (i = 0; i < BOARD_SIZE; i++)
     
551.         for (j = 0; j < BOARD_SIZE - 1; j++)
     
552.             if (board[i][j] == board[i][j+1])
     
553.                 return 1;
     
554. 
     
555.     for (i = 0; i < BOARD_SIZE - 1; i++)
     
556.         for (j = 0; j < BOARD_SIZE; j++)
     
557.             if (board[i][j] == board[i+1][j])
     
558.                 return 1;
     
559. 
     
560.     return 0;
     
561. }
     
562. 
     
563. /* ============================================================
     
564.    GDI绘图
     
565.    ============================================================ */
     
566. 
     
567. void DrawCell(hDC, value, x, y, w, h)
     
568. HDC hDC;
     
569. int value, x, y, w, h;
     
570. {
     
571.     char buf[16];
     
572.     int  len;
     
573.     int  idx;
     
574.     HBRUSH hBrush, hOldBrush;
     
575.     HPEN   hPen, hOldPen;
     
576. 
     
577.     idx = ValueToIndex(value);
     
578.     hBrush = hBrushes[idx];
     
579. 
     
580.     if (value >= 8 && value < 128)
     
581.         hPen = hPenWhite;
     
582.     else
     
583.         hPen = hPenBlack;
     
584. 
     
585.     hOldBrush = SelectObject(hDC, hBrush);
     
586.     hOldPen   = SelectObject(hDC, hPen);
     
587. 
     
588.     Rectangle(hDC, x, y, x + w, y + h);
     
589. 
     
590.     SelectObject(hDC, hOldBrush);
     
591.     SelectObject(hDC, hOldPen);
     
592. 
     
593.     if (value != 0) {
     
594.         SetBkMode(hDC, TRANSPARENT);
     
595.         SetTextColor(hDC, (value >= 8 && value < 128) ?
     
596.                           RGB(255,255,255) : RGB(0,0,0));
     
597.         sprintf(buf, "%d", value);
     
598.         len = strlen(buf);
     
599.         TextOut(hDC, x + (w - len * 8) / 2, y + (h - 14) / 2, buf, len);
     
600.     }
     
601. }
     
602. 
     
603. void DrawBoard(hDC)
     
604. HDC hDC;
     
605. {
     
606.     int i, j;
     
607.     int x, y;
     
608.     int top = 45;
     
609. 
     
610.     for (i = 0; i < BOARD_SIZE; i++) {
     
611.         for (j = 0; j < BOARD_SIZE; j++) {
     
612.             x = MARGIN + j * (CELL_W + MARGIN);
     
613.             y = top + i * (CELL_H + MARGIN);
     
614.             DrawCell(hDC, board[i][j], x, y, CELL_W, CELL_H);
     
615.         }
     
616.     }
     
617. }
     
618. 
     
619. /* 预创建所有GDI对象 */
     
620. void InitGDI()
     
621. {
     
622.     hBrushes[0]  = GetStockObject(LTGRAY_BRUSH);
     
623.     hBrushes[1]  = CreateSolidBrush(RGB(238, 228, 218));  /* 2 */
     
624.     hBrushes[2]  = CreateSolidBrush(RGB(237, 224, 200));  /* 4 */
     
625.     hBrushes[3]  = CreateSolidBrush(RGB(242, 177, 121));  /* 8 */
     
626.     hBrushes[4]  = CreateSolidBrush(RGB(245, 149, 99));   /* 16 */
     
627.     hBrushes[5]  = CreateSolidBrush(RGB(246, 124, 95));   /* 32 */
     
628.     hBrushes[6]  = CreateSolidBrush(RGB(246, 94, 59));    /* 64 */
     
629.     hBrushes[7]  = CreateSolidBrush(RGB(237, 207, 114));  /* 128 */
     
630.     hBrushes[8]  = CreateSolidBrush(RGB(237, 207, 114));  /* 256 */
     
631.     hBrushes[9]  = CreateSolidBrush(RGB(237, 207, 114));  /* 512 */
     
632.     hBrushes[10] = CreateSolidBrush(RGB(237, 207, 114));  /* 1024 */
     
633.     hBrushes[11] = CreateSolidBrush(RGB(237, 207, 114));  /* 2048 */
     
634.     hBrushes[12] = CreateSolidBrush(RGB(237, 207, 114));  /* 更大 */
     
635. 
     
636.     hPenBlack = GetStockObject(BLACK_PEN);
     
637.     hPenWhite = GetStockObject(WHITE_PEN);
     
638. }
     
639. 
     
640. /* 程序退出时统一清理 */
     
641. void CleanupGDI()
     
642. {
     
643.     int i;
     
644.     for (i = 1; i < 13; i++) {
     
645.         if (hBrushes[i])
     
646.             DeleteObject(hBrushes[i]);
     
647.     }
     
648. }
     
649. 
     
650. int ValueToIndex(value)
     
651. int value;
     
652. {
     
653.     switch (value) {
     
654.         case 0:    return 0;
     
655.         case 2:    return 1;
     
656.         case 4:    return 2;
     
657.         case 8:    return 3;
     
658.         case 16:   return 4;
     
659.         case 32:   return 5;
     
660.         case 64:   return 6;
     
661.         case 128:  return 7;
     
662.         case 256:  return 8;
     
663.         case 512:  return 9;
     
664.         case 1024: return 10;
     
665.         case 2048: return 11;
     
666.         default:   return 12;
     
667.     }
     
668. }
     
669. 
     
670. /* ============================================================
     
671.    对话框过程
     
672.    ============================================================ */
     
673. 
     
674. /* About 对话框过程 */
     
675. BOOL FAR PASCAL AboutDlg(hDlg, message, wParam, lParam)
     
676. HWND     hDlg;
     
677. unsigned message;
     
678. WORD     wParam;
     
679. LONG     lParam;
     
680. {
     
681.     if (message == WM_COMMAND && wParam == IDOK) {
     
682.         EndDialog(hDlg, TRUE);
     
683.         return TRUE;
     
684.     }
     
685.     if (message == WM_INITDIALOG)
     
686.         return TRUE;
     
687.     return FALSE;
     
688. }
     
689. 
     
690. /* HowToPlay 对话框过程（新增） */
     
691. BOOL FAR PASCAL HowToPlayDlg(hDlg, message, wParam, lParam)
     
692. HWND     hDlg;
     
693. unsigned message;
     
694. WORD     wParam;
     
695. LONG     lParam;
     
696. {
     
697.     if (message == WM_COMMAND && wParam == IDOK) {
     
698.         EndDialog(hDlg, TRUE);
     
699.         return TRUE;
     
700.     }
     
701.     if (message == WM_INITDIALOG)
     
702.         return TRUE;
     
703.     return FALSE;
     
704. }
     
705. 
     
706. /* ============================================================
     
707.    新增：存档文件读写函数
     
708.    设计思路：
     
709.    1. SaveGame() 将当前棋盘状态写入文本文件 2048.sav。
     
710.       文本格式：简单可靠，第一行为分数和游戏状态，随后为棋盘矩阵。
     
711.    2. LoadGame() 从 2048.sav 读取状态。
     
712.       成功返回 1，失败返回 0。
     
713.       成功读取后，应立即删除存档文件，避免下次启动干扰。
     
714.    3. 存档仅保存最后一次手动保存的状态。
     
715.    4. 游戏启动时会检查并加载存档，加载后文件被删除。
     
716.       之后的游戏过程都不会再使用该文件，直到用户再次手动存档。
     
717.    ============================================================ */
     
718. 
     
719. void SaveGame()
     
720. {
     
721.     FILE *fp;
     
722.     int i, j;
     
723. 
     
724.     fp = fopen("2048.sav", "w");
     
725.     if (fp == NULL)
     
726.         return;
     
727. 
     
728.     fprintf(fp, "%d %d\n", score, game_over);
     
729.     for (i = 0; i < BOARD_SIZE; i++) {
     
730.         for (j = 0; j < BOARD_SIZE; j++)
     
731.             fprintf(fp, "%d ", board[i][j]);
     
732.         fprintf(fp, "\n");
     
733.     }
     
734.     fclose(fp);
     
735. }
     
736. 
     
737. int LoadGame()
     
738. {
     
739.     FILE *fp;
     
740.     int i, j;
     
741. 
     
742.     fp = fopen("2048.sav", "r");
     
743.     if (fp == NULL)
     
744.         return 0;   /* 不存在存档 */
     
745. 
     
746.     if (fscanf(fp, "%d %d", &score, &game_over) != 2) {
     
747.         fclose(fp);
     
748.         return 0;
     
749.     }
     
750.     for (i = 0; i < BOARD_SIZE; i++)
     
751.         for (j = 0; j < BOARD_SIZE; j++) {
     
752.             if (fscanf(fp, "%d", &board[i][j]) != 1) {
     
753.                 fclose(fp);
     
754.                 return 0;
     
755.             }
     
756.         }
     
757.     fclose(fp);
     
758. 
     
759.     /* 修正：成功加载后，立即删除存档文件，避免下次启动干扰 */
     
760.     /* remove("2048.sav"); */
     
761.     return 1;
     
762. }
     
763. 
     
764. /* ============================================================
     
765.    分数历史记录读写函数（二进制文件，彻底避免玩家修改）
     
766.    ============================================================ */
     
767. 
     
768. /* 从文件读取历史，成功返回 TRUE，失败返回 FALSE */
     
769. BOOL GetScoreHistory(pHist)
     
770. ScoreHistory *pHist;
     
771. {
     
772.     FILE *fp;
     
773. 
     
774.     fp = fopen("2048.his", "rb");
     
775.     if (fp == NULL)
     
776.         return FALSE;
     
777. 
     
778.     if (fread(pHist, sizeof(ScoreHistory), 1, fp) != 1) {
     
779.         fclose(fp);
     
780.         return FALSE;
     
781.     }
     
782.     fclose(fp);
     
783.     return TRUE;
     
784. }
     
785. 
     
786. /* 将历史写入文件（若文件不存在则创建） */
     
787. void SetScoreHistory(pHist)
     
788. ScoreHistory *pHist;
     
789. {
     
790.     FILE *fp;
     
791. 
     
792.     fp = fopen("2048.his", "wb");
     
793.     if (fp == NULL)
     
794.         return;
     
795. 
     
796.     fwrite(pHist, sizeof(ScoreHistory), 1, fp);
     
797.     fclose(fp);
     
798. }
     
799. 
     
800. /* 游戏结束时调用，传入本局得分，自动更新历史文件 */
     
801. void UpdateScoreHistory(newScore)
     
802. int newScore;
     
803. {
     
804.     ScoreHistory hist;
     
805.     int i;
     
806. 
     
807.     /* 若文件不存在，则初始化空历史 */
     
808.     if (!GetScoreHistory(&hist)) {
     
809.         hist.highscore = 0;
     
810.         hist.count = 0;
     
811.         for (i = 0; i < 5; i++)
     
812.             hist.recent[i] = 0;
     
813.     }
     
814. 
     
815.     /* 更新最高分 */
     
816.     if (newScore > hist.highscore)
     
817.         hist.highscore = newScore;
     
818. 
     
819.     /* 将新分数插入 recent[0]，后移原有分数 */
     
820.     for (i = 4; i > 0; i--)
     
821.         hist.recent[i] = hist.recent[i - 1];
     
822.     hist.recent[0] = newScore;
     
823.     if (hist.count < 5)
     
824.         hist.count++;
     
825. 
     
826.     SetScoreHistory(&hist);
     
827. }
     
828. 
     
829. /* ============================================================
     
830.    分数板对话框过程
     
831.    ============================================================ */
     
832. BOOL FAR PASCAL ScoreboardDlg(hDlg, message, wParam, lParam)
     
833. HWND     hDlg;
     
834. unsigned message;
     
835. WORD     wParam;
     
836. LONG     lParam;
     
837. {
     
838.     ScoreHistory hist;
     
839.     char buf[512];
     
840.     char line[64];
     
841.     int i;
     
842. 
     
843.     switch (message) {
     
844. 
     
845.     case WM_INITDIALOG:
     
846.         /* 读取历史，若失败则显示空数据 */
     
847.         if (!GetScoreHistory(&hist)) {
     
848.             hist.highscore = 0;
     
849.             hist.count = 0;
     
850.         }
     
851. 
     
852.         /* 构建多行文本（注意换行用 \r\n） */
     
853.         buf[0] = '\0';
     
854.         sprintf(buf + strlen(buf), "Best Score: %d\r\n", hist.highscore);
     
855.         sprintf(buf + strlen(buf), "------------------------\r\n");
     
856.         sprintf(buf + strlen(buf), "Recent Scores:\r\n");
     
857.         for (i = 0; i < hist.count && i < 5; i++) {
     
858.             sprintf(line, "%d. %d\r\n", i + 1, hist.recent[i]);
     
859.             strcat(buf, line);
     
860.         }
     
861.         sprintf(buf + strlen(buf), "------------------------\r\n");
     
862.         sprintf(buf + strlen(buf), "Current Score: %d", score);
     
863. 
     
864.         /* 设置到编辑框（IDC_SCOREBOARD_EDIT） */
     
865.         SetDlgItemText(hDlg, IDC_SCOREBOARD_EDIT, buf);
     
866.                 /* 设置完文本后，将焦点转移到 OK 按钮，避免编辑框文字被选中 */
     
867.         SetFocus(GetDlgItem(hDlg, IDOK));
     
868.         return FALSE;   /* 返回 FALSE 表示你主动设置了焦点，系统不再自动设置 */
     
869. 
     
870.     case WM_COMMAND:
     
871.         if (wParam == IDOK) {
     
872.             EndDialog(hDlg, TRUE);
     
873.             return TRUE;
     
874.         }
     
875.         break;
     
876.     }
     
877.     return FALSE;
     
878. }

复制代码

有趣的是win1sdk缺少叠加窗口类的api但是为win1写的程序却可以巧妙的运行！！！在添加256色驱动后有种古早Android风格！！！！
效果图：

FishC

看到你用 Windows 1.03 SDK + MSC 4.0 写 2048，真是勇气可嘉！Win16 时代的 API 确实与 Win32 有差异，但核心思想相通，这段代码里藏着不少早期 Windows 编程的“独门绝技”。下面我帮你梳理一下代码中需要注意的地方，以及一些可以改进的点。

• 数组声明与使用不匹配：代码里出现了 board = 0 之类的写法，但 board 没有被定义成二维数组。应该统一声明为 int board[4][4];，之后所有访问都要带下标。
• 随机放置方块的逻辑有误：AddRandomTile 中 empty 数组只记录了最后一个空位，应该用数组存储所有空位坐标再随机选取。
• GDI 画刷数组 InitGDI 中 hBrushes 被重复赋值，导致只创建了最后一个画刷，前面的全部泄漏。应该声明为 HBRUSH hBrushes[13];。
• Move 函数里的转置和翻转操作中，数组索引错误（例如 board = board; 缺少 [i][j] 和 [j][i]）。正确写法需要明确指定两个下标。
• 对话框过程的类型转换：Win16 下 MakeProcInstance 返回的是 FARPROC，但 DialogBox 最后一个参数期望的是 DLGPROC 类型，需要强制转换。
• 资源 ID 宏未定义：代码中引用了 IDM_NEWGAME、DLG_ABOUT 等，但头文件 2048.h 没有给出，需要确认 .rc 文件中的定义。
  

虽然代码有不少 bug，但你选择的这个环境本身就是“地狱难度”——K&R 函数定义、无重叠窗口的 API、全局数据段、MakeProcInstance……这些在 Win32 中早已消失。能跑起来并截图，说明你已经克服了很大的挑战。

建议先修正数组声明和 GDI 泄漏，然后逐步调试 Move 逻辑。如果你愿意，我可以针对某个具体问题（比如 MoveLeft 的实现）给出在 Win16 下正确的 K&R 写法。继续加油，老平台能带来很多底层理解！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

健康快乐

FishC 发表于 2026-6-24 12:35
看到你用 Windows 1.03 SDK + MSC 4.0 写 2048，真是勇气可嘉！Win16 时代的 API 确实与 Win32 有差异，但 ...

ok记录了！！！
我有点不太敢动它了！！！每次修改之后一堆报错或者出现莫名其妙的问题！！！
特别是不小心用现代编辑器打开后被插入的各种隐形字符！头大！！！！

FishC

健康快乐 发表于 2026-06-24 12:46
FishC 发表于 2026-6-24 12:35
看到你用 Windows 1.0 ...

看到你的困扰，完全理解——在 DOS + Windows 1.03 环境下调试，每次修改都像在踩地雷。这里给你几个“保命”建议，能最大程度减少意外：

• 用“纯文本”编辑器：不要用现代 IDE 或 Word 类工具。推荐 Windows 自带的 Notepad（记事本）或者 DOS 下的 EDIT。它们不会自动插入格式化字符。
• 文件换行格式：MS-DOS 使用 CR+LF（0x0D, 0x0A）。如果你在 Windows 10/11 上编辑，保存时请选择“ANSI”编码和“Windows (CRLF)”换行。很多现代编辑器默认用 LF（Unix），放进 MSC 5.0 编译器会报错。
• 分步修改，局部测试：每次只改一个函数或一行逻辑，改完立即编译。不要一次改动太多。错误定位难，往往是因为多个改动相互影响。
• 保留前一个版本：在 DOS 下可以用 COPY 命令备份，比如 copy 2048.c 2048_prev.c。出了问题立刻恢复。
• 编译前检查大括号：K&R 风格要求函数左大括号在单独一行，且不能省略。如果某个函数报错“syntax error”，大概率是括号不匹配。
  

关于“隐形字符”——主要是“非断行空格”和“全角符号”，现代编辑器误操作可能插入。最保险的手段：用 DOS 下的 TYPE 命令查看原始文件是否正常。例如：

1. TYPE 2048.C | MORE

复制代码

如果看到奇怪字符，说明编辑器污染了。这时直接恢复备份，或者用 DEBUG 手动清除。

你已经在非常苛刻的环境下跑起来了，这是很多现代程序员做不到的。放轻松，每次只解决一个小问题，比如先把数组 board 改成二维的、修好画刷数组。祝你成功！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。