中国象棋小游戏（C版）

中国象棋小游戏（C版）

! 此文仅展示此游戏的最简单版本，可以实现中国象棋双人对战的基本功能。更多功能体验可访问上方链接。

说明：

• #include 一个在 C/C++ 中用于图形编程的头文件，主要用于创建和操作图形界面。具有绘制图形、设置颜色、鼠标和键盘时间处理等功能。
  
• #include 提供了对控制台输入/输出的简单操作，如字符读取和屏幕刷新。
  
• #include 包含了 Windows API 的各种函数和数据结构定义，允许程序直接调用 Windows 操作系统的功能。可用于窗口创建与管理、进程和线程操作、文件操作、系统信息获取等。
  
• #include 提供了多媒体功能，包括音频和定时器功能。同时需要链接winmm.lib库，通过#pragma comment(lib,"winmm.lib")实现
  

整体思路

• 创建图形窗口，绘制中国象棋棋局图案
  
• 定义棋子，并在棋局上绘制初始化棋子
  
• 实现游戏控制功能。即可通过鼠标操作实现棋子的移动以及红黑双方的交换操作
  
• 添加棋子的走法规则，将军的判定以及胜负判定
  
• 添加背景音乐、走棋音效等
  
• 添加红黑双方计时功能
  
• 打包软件
  

实现过程

• 创建图形窗口，绘制中国象棋棋局图案。
  ​        我们先看此步骤完成后的结果。
  
  
  
  ​        只要对graphics.h有所了解，创建图形窗口并不困难。
  ​        我们首先在主函数中直接初始化图形窗口。
  1. #include<stdio.h>
  2. #include<graphics.h>
  3. int main(){
  4.         initgraph(800,800);
  5. }

  复制代码
  ​        接下来我们需要定义一个绘制游戏的函数。首先我们可以定义一个行数、列数、间隔以及棋盘格子大小
  1. #define INTERVAL 50 // 定义间隔
  2. #define CHESS_GRID_SIZE 70 // 定义棋盘格子大小
  3. #define ROW 10 // 定义行数
  4. #define COL 9 // 定义列数

  复制代码
  ​        接下来绘制棋局的格子
  1. void GameDraw() {
  2.         setbkcolor(RGB(252, 215, 162));        // 设置背景色
  3.         cleardevice();        // 清屏
  4.         setlinecolor(BLACK); // 设置线条颜色
  5.         setlinestyle(PS_SOLID, 2); // 设置线条样式
  6.         setfillcolor(RGB(252, 215, 162));
  7.         //绘制外边框
  8.         fillrectangle(INTERVAL - 5, INTERVAL - 5, CHESS_GRID_SIZE * 8 + INTERVAL + 5, CHESS_GRID_SIZE * 9 + INTERVAL + 5);
  9.         // 绘制棋盘
  10.         for (int i = 0;i < 10;i++) {
  11.                 //画横线
  12.                 line(INTERVAL, i * CHESS_GRID_SIZE + INTERVAL, CHESS_GRID_SIZE * 8 + INTERVAL, i * CHESS_GRID_SIZE + INTERVAL);
  13.                 //画竖线
  14.                 if (i < 9) {
  15.                         line(i * CHESS_GRID_SIZE + INTERVAL, INTERVAL, i * CHESS_GRID_SIZE + INTERVAL, 9 * CHESS_GRID_SIZE + INTERVAL);
  16.                 }
  17.         }
  18. }

  复制代码
  ​        接着显示“楚河汉界”文字
  1. void GameDraw(){
  2.         //显示楚河，汉界
  3.         fillrectangle(INTERVAL, 4 * CHESS_GRID_SIZE + INTERVAL, 8 * CHESS_GRID_SIZE + INTERVAL, 5 * CHESS_GRID_SIZE + INTERVAL);
  4.         //显示文字
  5.         settextcolor(BLACK);
  6.         settextstyle(50, 0, "楷体");
  7.         char river[25] = "楚 河        汉 界";
  8.         //让文字居中
  9.         int twidth = textwidth(river);
  10.         int theight = textheight(river);
  11.         twidth = (8 * CHESS_GRID_SIZE - twidth) / 2;
  12.         theight = (CHESS_GRID_SIZE - theight) / 2;
  13.         outtextxy(INTERVAL + twidth, 4 * CHESS_GRID_SIZE + theight + INTERVAL, river);
  14. }

  复制代码
  ​        最后画米字完成第一步。
  1. void GameDraw(){
  2.         //画米字
  3.         line(3 * CHESS_GRID_SIZE + INTERVAL, INTERVAL, 5 * CHESS_GRID_SIZE + INTERVAL, 2 * CHESS_GRID_SIZE + INTERVAL);
  4.         line(5 * CHESS_GRID_SIZE + INTERVAL, INTERVAL, 3 * CHESS_GRID_SIZE + INTERVAL, 2 * CHESS_GRID_SIZE + INTERVAL);
  5.         line(3 * CHESS_GRID_SIZE + INTERVAL, 7 * CHESS_GRID_SIZE + INTERVAL, 5 * CHESS_GRID_SIZE + INTERVAL, 9 * CHESS_GRID_SIZE + INTERVAL);
  6.         line(5 * CHESS_GRID_SIZE + INTERVAL, 7 * CHESS_GRID_SIZE + INTERVAL, 3 * CHESS_GRID_SIZE + INTERVAL, 9 * CHESS_GRID_SIZE + INTERVAL);  
  7. }

  复制代码
• 定义棋子，并在棋局上绘制初始化棋子
  ​        我们先看此步骤完成后的结果。
  
  
  
  

​                根据中国象棋游戏规则，棋子分为红黑双方，不同棋子有不同的走法和不同的过河标准。
​                于是我们首先需要定义红黑双方的棋子名称，这里使用两个指向常量的指针数组分别代表红方棋子和黑方棋子。（用指针数组存储每个棋子名称字符串的起始地址，且是只读模式。更灵活高效且易于修改和维护）

1. const char* redChess[7] = { "車","馬","相","仕","帥","炮","兵" };        // 红方棋子
2. const char* blackChess[7] = { "车","马","象","士","将","砲","卒" };        // 黑方棋子

复制代码

​                每个棋子的位置由横纵坐标确定，且每个棋子都有名称、坐标、红黑方、是否过河等属性。于是我们定义一个棋子结构体如下：

1. //定义棋子结构体
2. struct Chess {
3.         char name[4];        // 棋子名称一个汉字
4.         int x;        // 棋子x坐标
5.         int y;        // 棋子y坐标
6.         char type;        // 棋子类型(红方还是黑方)
7.         bool flag;        // 棋子是否过河；
8. }map[ROW][COL];

复制代码

​                接下来就需要对结构体进行初始化，在相应的位置放入相应的棋子。

1. //游戏初始化
2. void GameInit() {
4.         //遍历二维数组
5.         for (int i = 0;i < ROW;i++) {
6.                 int temp = 0, temp1 = 0, temp2 = 1;
7.                 for (int k = 0;k < COL;k++) {
8.                         char chessname[4] = ""; // 定义棋子名称
9.                         char mcolor = 'B';        // 定义棋子颜色黑色
10.                         if (i <= 4) {        // 黑棋初始化
11.                                 if (i == 0) {        //第一行棋子初始化
12.                                         if (temp <= 4) temp++;
13.                                         else {
14.                                                 temp1 = 4 - temp2;
15.                                                 temp2++;
16.                                         }
17.                                         sprintf(chessname, "%s", blackChess[temp1]);
18.                                         temp1++;
19.                                 }
20.                                 //设置砲
21.                                 if (i == 2 && (k == 1 || k == 7)) {
22.                                         strcpy(chessname, blackChess[5]);
23.                                 }
24.                                 //设置卒
25.                                 if (i == 3 && (k % 2 == 0)) {
26.                                         strcpy(chessname, blackChess[6]);
27.                                 }
28.                         }
29.                         else {
30.                                 mcolor = 'R';        // 定义棋子颜色红色
31.                                 if (i == 9) {        //最后一行棋子初始化
32.                                         if (temp <= 4) temp++;
33.                                         else {
34.                                                 temp1 = 4 - temp2;
35.                                                 temp2++;
36.                                         }
37.                                         sprintf(chessname, "%s", redChess[temp1]);
38.                                         temp1++;
39.                                 }
40.                                 //设置炮
41.                                 if (i == 7 && (k == 1 || k == 7)) {
42.                                         strcpy(chessname, redChess[5]);
43.                                 }
44.                                 //设置兵
45.                                 if (i == 6 && (k % 2 == 0)) {
46.                                         strcpy(chessname, redChess[6]);
47.                                 }
48.                         }
49.                         map[i][k].type = mcolor;
50.                         strcpy(map[i][k].name, chessname);
51.                         map[i][k].flag = false;
52.                         map[i][k].x = k * CHESS_GRID_SIZE + INTERVAL;
53.                         map[i][k].y = i * CHESS_GRID_SIZE + INTERVAL;
54.                 }
55.         }
56. }

复制代码

​        最后，我们继续在绘制函数中添加对棋子的选中效果

1. void DameDraw(){
2.         //绘制棋子
3.         settextstyle(40, 0, "楷体");  // 设置字体大小
4.         for (int i = 0;i < ROW;i++) {
5.                 for (int k = 0;k < COL;k++) {
6.                         if (strcmp(map[i][k].name, "") != 0) {
7.                                 //绘制棋子
8.                                 if (map[i][k].type == 'B') {
9.                                         settextcolor(BLACK);
10.                                         setlinecolor(BLACK);
11.                                 }
12.                                 else {
13.                                         settextcolor(RED);
14.                                         setlinecolor(RED);
15.                                 }
16.                                 fillcircle(map[i][k].x, map[i][k].y, 30);
17.                                 outtextxy(map[i][k].x - 20, map[i][k].y - 20, map[i][k].name);
19.                         }
20.                 }
21.         }   
22. }

复制代码

添加棋子的走法规则，将军的判定以及胜负判定
​        这一步是整个象棋游戏的关键步骤。我们需要定义一个检验函数，对每一个棋子进行走法检验。
首先定义该检验函数：

1. POINT begin = { -1,-1 }, end = { -1,-1 };        // 记录前后两次点击的坐标
2. MOUSEMSG msg;
3. bool isRedTurn = true; // 红方先手

复制代码

• 第一步需要规定禁止吃己方棋子：
  ​        这个不能实现，只需要当判断目标位置存在棋子且该棋子的阵营属性和移动的棋子相同，则禁止移动即可。
  1. if (MouseHit) {                 // 检测是否有鼠标事件
  2.     msg = GetMouseMsg();        // 获取鼠标消息
  3.     if (msg.uMsg == WM_LBUTTONDOWN) {  // 判断是否为左键按下事件
  4.         // ...后续处理...
  5.     }
  6. }

  复制代码
• 第二步检验车的走法
  
  
  
  • 车的走法就是必须横向或纵向移动（fromI == toI 或 fromK == toK）
    
  • 路径上所经过的格子都必须为空即可。
    
  1. int k = (msg.x - INTERVAL + CHESS_GRID_SIZE / 2) / CHESS_GRID_SIZE;
  2. int i = (msg.y - INTERVAL + CHESS_GRID_SIZE / 2) / CHESS_GRID_SIZE;
  4. if (k < 0 || k >= COL || i < 0 || i >= ROW) return; // 超出棋盘范围则退出

  复制代码
• 第三步检验马的走法
  
  
  
  • 马的移动方式是日字格（横向1格，纵向2格，或横向2格，纵向1格）。
    
  • 判断其移动是否存在蹩马脚的情况（即相邻格子必须为空）
    
  1. if (begin.x == -1) {  // 首次点击，选择起点
  2.     // 必须选择己方棋子
  3.     if ((isRedTurn && map[i][k].type == 'R') || (!isRedTurn && map[i][k].type == 'B')) {
  4.         begin.x = k;
  5.         begin.y = i;
  6.     }
  7. }

  复制代码
• 第四步检验象的走法
  
  
  
  • 象的移动是田字格（横向和纵向均移动2格）
    
  • 田字中间必须为空。
    
  • 象无法过河。
    
  1. else {  // 第二次点击，选择终点
  2.     end.x = k;
  3.     end.y = i;
  5.     // 检查目标位置是否为空（未完成逻辑）
  6.     int flagg = 0;
  7.     if (strcmp(map[end.y][end.x].name, "") == 0)  flagg++;
  9.     // 移动棋子到目标位置
  10.     strcpy(map[end.y][end.x].name, map[begin.y][begin.x].name);
  11.     map[end.y][end.x].type = map[begin.y][begin.x].type;
  12.     map[end.y][end.x].flag = map[begin.y][begin.x].flag;
  14.     // 清空起点位置
  15.     strcpy(map[begin.y][begin.x].name, "");
  17.     // 切换回合
  18.     isRedTurn = !isRedTurn;
  20.     // 重置起点
  21.     begin.x = -1;
  22. }

  复制代码
• 第五步检验士的走法
  
  
  
  • 士在己方九宫格内移动
    
  • 每次只能斜向移动一格（横向和纵向均移动1格）
    
  1. void GameControl() {
  2.         if (MouseHit {
  3.                 msg = GetMouseMsg();
  4.                 if (msg.uMsg == WM_LBUTTONDOWN) {
  5.                         //转换为棋盘坐标
  6.                         int k = (msg.x - INTERVAL + CHESS_GRID_SIZE / 2) / CHESS_GRID_SIZE;
  7.                         int i = (msg.y - INTERVAL + CHESS_GRID_SIZE / 2) / CHESS_GRID_SIZE;
  8.                         //判断是否在棋盘内
  9.                         if (k < 0 || k >= COL || i < 0 || i >= ROW) return;
  10.                         if (begin.x == -1) {        //第一次点击
  11.                                 //必须选择己方棋子
  12.                                 if ((isRedTurn && map[i][k].type == 'R') || (!isRedTurn && map[i][k].type == 'B')) {
  13.                                         begin.x = k;
  14.                                         begin.y = i;
  15.                                 }
  16.                         }else {        //第二次点击
  17.                                 end.x = k;
  18.                                 end.y = i;
  19.                                 //执行移动
  20.                                 int flagg = 0;
  21.                                 if (strcmp(map[end.y][end.x].name, "") == 0)  flagg++;
  22.                                 //移动棋子
  23.                                 strcpy(map[end.y][end.x].name, map[begin.y][begin.x].name);
  24.                                 map[end.y][end.x].type = map[begin.y][begin.x].type;
  25.                                 map[end.y][end.x].flag = map[begin.y][begin.x].flag;
  26.                                 //清空原位置
  27.                                 strcpy(map[begin.y][begin.x].name, "");
  28.                                 //交换走棋方
  29.                                 isRedTurn = !isRedTurn;
  30.                                 begin.x = -1;        //重置选择
  31.                         }
  32.                 }
  33.         }
  34. }

  复制代码
• 第六步检验将的走法
  
  
  
  • 只能在己方九宫格内移动
    
  • 每次只能横向或纵向移动一格
    
  1. void GameDraw(){
  2.     //绘制选中效果
  3.     if (i == begin.y && k == begin.x) {
  4.         setlinecolor(BLUE);
  5.         circle(map[i][k].x, map[i][k].y, 30);
  6.         circle(map[i][k].x, map[i][k].y, 32);
  7.     }   
  8. }

  复制代码
• 第七步检验炮的走法
  
  
  
  • 必须直线移动
    
  • 若目标为空，路径上不能有任何子
    
  • 若目标位敌方棋子，路径上必须恰好有一个棋子
    
  1. bool CheckMove(int fromI, int fromK, int toI, int toK) {        }

  复制代码
• 第八步检验兵的走法
  
  
  
  • 未过河
    
    
    
    • 只能向前移动一格。
      
    • 过河后更新标志位。
      
    
    
  • 已过河
    
    
    
    • 可向前或横向移动一格。
      
    
    
  1. struct Chess fromChess = map[fromI][fromK];
  2. struct Chess toChess = map[toI][toK];
  4. if (toChess.type == fromChess.type && strcmp(toChess.name, "") != 0)
  5.     return false;

  复制代码
  综上，我们将这些函数插入游戏控制函数内即可。
  
  

添加背景音乐、走棋音效等
​        这一步很简单，直接给出代码。

1. if (strcmp(fromChess.name, "车") == 0 || strcmp(fromChess.name, "車") == 0) {
2.     // 必须直线移动
3.     if (fromI != toI && fromK != toK) return false;
5.     // 计算步长和距离
6.     int step = (fromI == toI) ? (toK > fromK ? 1 : -1) : (toI > fromI ? 1 : -1);
7.     int distance = (fromI == toI) ? abs(toK - fromK) : abs(toI - fromI);
9.     // 检查路径是否被阻挡
10.     for (int i = 1; i < distance; i++) {
11.         int x = (fromI == toI) ? fromI : fromI + step * i;
12.         int y = (fromI == toI) ? fromK + step * i : fromK;
13.         if (strcmp(map[x][y].name, "") != 0) return false;
14.     }
15.     return true;
16. }

复制代码

添加红黑双方计时功能
​        我们先看此步骤完成后的结果。

​        这里我们只是实现最简单的计时功能，即双方步时60秒，总时长10分钟。
​        首先我们需要定义时间结构体包括总时间和当前步时。

1. else if (strcmp(fromChess.name, "马") == 0 || strcmp(fromChess.name, "馬") == 0) {
2.     int dx = abs(toK - fromK);
3.     int dy = abs(toI - fromI);
4.     // 必须走日字
5.     if (!((dx == 1 && dy == 2) || (dx == 2 && dy == 1))) return false;
7.     // 检查蹩马腿
8.     int blockX = fromI + (toI - fromI) / 2;
9.     int blockY = fromK + (toK - fromK) / 2;
10.     if (strcmp(map[blockX][blockY].name, "") != 0) return false;
12.     return true;
13. }

复制代码

​        接着我们在游戏初始化函数中添加初始化计时器。

1. else if (strcmp(fromChess.name, "相") == 0 || strcmp(fromChess.name, "象") == 0) {
2.     int dx = abs(toK - fromK);
3.     int dy = abs(toI - fromI);
4.     // 必须走田字
5.     if (dx != 2 || dy != 2) return false;
7.     // 检查田字中心是否被阻挡
8.     int centerX = (fromI + toI) / 2;
9.     int centerY = (fromK + toK) / 2;
10.     if (strcmp(map[centerX][centerY].name, "") != 0) return false;
12.     // 不能过河
13.     if (fromChess.type == 'B' && toI > 4) return false; // 黑象不能过楚河
14.     if (fromChess.type == 'R' && toI < 5) return false; // 红象不能过汉界
16.     return true;
17. }

复制代码

​        在游戏控制函数中添加双方交换时步时的重置

1. else if (strcmp(fromChess.name, "仕") == 0 || strcmp(fromChess.name, "士") == 0) {
2.     // 九宫格范围检查
3.     if (fromChess.type == 'B') {
4.         if (toI > 2 || toK < 3 || toK > 5) return false; // 黑方九宫格
5.     } else {
6.         if (toI < 7 || toK < 3 || toK > 5) return false; // 红方九宫格
7.     }
9.     // 斜向移动一格
10.     return (abs(toK - fromK) == 1 && abs(toI - fromI) == 1);
11. }

复制代码

​        然后我们在游戏绘制函数中将时间显示在棋盘右侧。

1. else if (strcmp(fromChess.name, "帥") == 0 || strcmp(fromChess.name, "将") == 0) {
2.     // 九宫格范围检查
3.     if (fromChess.type == 'B') {
4.         if (toI > 2 || toK < 3 || toK > 5) return false;
5.     } else {
6.         if (toI < 7 || toK < 3 || toK > 5) return false;
7.     }
9.     // 直线移动一步
10.     if ((abs(toK - fromK) + abs(toI - fromI)) != 1) return false;
11.     return true;
12. }

复制代码

​        最后，在主函数中实现对时间的更新。
​        再结合之前的函数，我们写出主函数即可实现中国象棋的最简化版。
[code]int main() {        initgraph(800, 800, SHOWCONSOLE);        // 初始化图形窗口        SoundInit();        // 初始化音效        PlayBGM();        // 播放背景音乐        GameInit();        // 初始化游戏        while (true) {                GameControl();  // 触发时间扣除                // 更新时间逻辑（每秒更新一次）                DWORD currentTime = GetTickCount();                DWORD elapsed = currentTime - lastUpdateTime;                if (elapsed >= 1000) { // 超过1秒                        int seconds = elapsed / 1000; // 计算经过的整秒数                        // 扣除当前玩家的总时间和步时                        if (isRedTurn) {                                redTimer.totalTime -= seconds;                                redTimer.stepTime -= seconds;                        }                        else {                                blackTimer.totalTime -= seconds;                                blackTimer.stepTime -= seconds;                        }                        lastUpdateTime = currentTime;                        // 检查超时                        if (redTimer.totalTime 添加>新建项目搜索选择"setup Project"模板
配置项目名称
</ul>配置安装内容

• 主程序添加：右键Application Folder>Add>项目输出>选择主输出
  
• 资源文件处理：将"sound"音效文件夹拖入Application Folder（确保所有依赖的DLL被包含）
  

配置快捷方式

• 右键Application>Add>文件>选择所需的快捷方式图案.ico文件（图片转换成.ico格式可以通过PS转换，需要提前配置插件)
  
• 右键主输出>创建快捷方式
  
• 将快捷方式拖入User's Desktop和User's Programs Menu
  
• 右键快捷方式>属性窗口>Icon>Browse>Browse>选择Application Folder文件中的ico文件>OK
  

处理依赖项

• 右键Application Folder>Add>文件>找到vcredist_x64.exe(路径：VS安装目录\VC\Redist\MSVC\版本号)
  

生成安装包

• 右键安装项目>生成
  
• 在输出目录即可获取Setup.exe和.msi文件
  

</ol>
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！