• 用VS软件开发“中国象棋“游戏＜笔记摘录＞

     整体架构如上

    1.很直观地去看这个中国象棋的界面,数一下它有多少行和多少列.

    10行,9列:要注意这里数的是安放象棋的位置,有10行9列

    这里我们首先想到的必然是二维数组,每一个行列交叉的点都设置成二维数组a[i][j]这样的格式,以此来确定棋盘上面每一个棋子的位置和走向.

    我们把上面安放棋子的二维数组定义成一个地图,也就是map[i][j]的格式,但同时要注意,每一个象棋棋子都有行,列,颜色,是否过河和名称(也就是什么棋子)几种定义区分.

    那么这里我们就需要把棋子定义成一个结构.如下:

    1. struct  Chesscoordinate//棋子综合信息
    2. {
    3.     int x;
    4.     int y;
    5.     DWORD type;  //颜色
    6.     bool river;//是否过河
    7.     int id;
    8. };

    当定义了棋子综合信息,我们是不是需要每一个信息都拓展一下?

    x代表的是在棋盘上面的列,也就是竖行,y代表的是棋子在棋盘上面的行,也就是横线,而type代表的棋子的颜色,棋子颜色可以分为黑色和红色两种;river设置成bool型的,只需要判断棋子是否过河就可以了.最后id定义的是棋子上面的名称,比如将,帅等.

    接下来我们就来VS当中进行棋子的程序定义拓展:

    1. #define distance  35//窗口线与棋盘边界线的距离
    2. #define   longth  65//棋盘方格的长
    3. #define   high   61//棋盘方格的宽

    distance longth 和high我们都把其设置成宏,这个就要回溯到棋盘上面,把棋盘假设成一个xy的二维坐标,那么要定义每一个棋子的位置,或者说是每一行与每一列的交叉点,就要用到上面三个宏定义.

    比如左上角第一个棋子的坐标可以表示为:

    map[0][0].x=distance;

    map[0][0].y=distance

    而第一行第二个棋子的坐标可以表示为:

    map[1][0].x=distance+longth;

    map[1][0].y=distance

    依次类推......

    1. int  xx(int a)//数组下标转换成坐标
    2. {
    3.     a = distance + longth * a;
    4.     return a;
    5. }
    6. int  yy(int a)
    7. {
    8.     a = distance + high * a;
    9.     return a;
    10. }

    我们可以推断出每一个棋子的坐标,都可以通过上面几个宏定义以及棋子的实际行列表示出来,

    1. enum pieces
    2. {
    3.     SPACE = -1,
    4.     車, 馬, 象, 士, 将, 炮, 卒,
    5.     车, 马, 相, 仕, 帥, 砲, 兵,
    6.     BEGIN, END,
    7.  
    8. };
    9. enum pieces redchess[] = { 車,馬,象,士,将,炮,卒, };
    10. enum pieces blackchess[] = { 车,马,相,仕,帥,砲,兵, };
    11. enum pieces state = BEGIN;
    12. struct move {  //鼠标选中的棋子
    13.     int beginx;
    14.     int beginy;
    15.     int endx;
    16.     int endy;
    17.     int state;
    18. }moving = { -1,-1,-1,-1,BEGIN };
    19. const char* chessname[] = { "車","馬","象","士","将","炮","卒","车","马","相","仕","帥","砲","兵", };

    这里我们把棋子的id设置成一个联合结构数组,因为里面的棋子的id都基本不同,同时我们考虑到了棋子要进行运动,把棋子的开始状态设置为BEGIN

    而新建一个move的结构,表示鼠标选中棋子的基本信息.begin的行列和结束的行列和运行状态.

    最后回到棋子id上面,我们是不是需要把这些id都设置到棋子或者棋盘上面啊,采用常量字符数组的形式,把棋盘上面所有的棋子都表示出来.

    而把刚才的map[i][j]二维数组同样定义成一个二维结构数组.如下:

    1. struct Chesscoordinate  map[9][10];//坐标
    2. struct Chesscoordinate  AImap[9][10];//坐标

    同时,我们设置了AImap[i][j]的二维结构数组,看看是否下面在进行棋子移动的时候,我们会用到.

    这里i=9,j=10是根据我们上面看中国象棋棋盘得到的数据.

    2.我们要开始加载图片信息了,把我们已经有的棋盘素材放在同文件下面,然后采用下面程序,就可以在窗口当中显示出中国棋盘的背景图.

    1. void begining()
    2. {
    3.     loadimage(&img, "D:/program/Project3-chess successful/1.png");
    4.     initgraph(img.getwidth(), img.getheight(), 1); //初始化图形系统
    5.     putimage(0, 0, &img);//输出开始界面；

    至于,loadimage()和initgraph()函数以及putimage()函数三者的基本理解和解释,建议去搜索,都有比较详细的解释.这里我们解释一下initgraph()函数的基本含义:

    这个函数用于初始化绘图环境。

    1. HWND initgraph(
    2.     int width,
    3.     int height,
    4.     int flag = NULL
    5. );

    参数：

    width   绘图环境的宽度。

    height   绘图环境的高度。

    flag  绘图环境的样式，默认为 NULL。

    上面程序的基本思路也就不言而喻:先加载或者找到我们素材的地址,然后定义出素材的宽和长度,然后再输出这个棋盘背景.

    当输出完背景之后,我们是不是要先把所有的棋子放在初始位置,也就是初始化棋盘?

    1. void  coord()//棋子信息赋值
    2. {
    3.     loadimage(&img, "D:/program/Project3-chess successful/1.png");
    4.     putimage(0, 0, &img);//输出棋盘
    5.  
    6.     for (int i = 0; i <= 8; i++)
    7.     {
    8.  
    9.         for (int j = 0; j <= 9; j++)//遍历二维数组
    10.         {
    11.             enum pieces chessid = SPACE;//先把全部位置的id赋值为SAPCE
    12.             DWORD  chesstype;//定义颜色中间变量
    13.             if (j <= 4)
    14.             {
    15.                 chesstype = BLACK;//黑方
    16.                 if (j == 0)
    17.                 {
    18.                     if (i <= 4)
    19.                     {
    20.                         chessid = blackchess[i];//
    21.                     }
    22.                     else
    23.                     {
    24.                         chessid = blackchess[8 - i];
    25.                     }
    26.  
    27.                 }
    28.                 if (j == 2 && (i == 1 || i == 7))
    29.                 {
    30.                     chessid = blackchess[5];
    31.  
    32.                 }
    33.  
    34.                 if (j == 3 && (i == 0 || i == 2 || i == 4 || i == 4 || i == 6 || i == 8))
    35.                 {
    36.                     chessid = blackchess[6];
    37.                 }
    38.  
    39.             }
    40.             else
    41.             {
    42.                 chesstype = RED;//红方
    43.                 if (j == 6 && (i == 0 || i == 2 || i == 4 || i == 6 || i == 8))
    44.                 {
    45.                     chessid = redchess[6];
    46.                 }
    47.                 if (j == 7 && (i == 1 || i == 7))
    48.                 {
    49.                     chessid = redchess[5];
    50.  
    51.                 }
    52.  
    53.                 if (j == 9)
    54.                 {
    55.  
    56.                     if (i <= 4)
    57.                     {
    58.                         chessid = redchess[i];
    59.                     }
    60.                     else
    61.                     {
    62.                         chessid = redchess[8 - i];
    63.                     }
    64.                 }
    65.  
    66.             }//依次赋值
    67.             map[i][j].id = chessid;
    68.             map[i][j].river = false;
    69.             map[i][j].type = chesstype;
    70.             map[i][j].x = distance + longth * i;
    71.             map[i][j].y = distance + high * j;
    72.  
    73.         }
    74.     }
    75.     for (int i = 0; i <= 8; i++)
    76.     {
    77.         for (int j = 0; j <= 9; j++)
    78.         {
    79.             if (map[i][j].id == SPACE)
    80.             {
    81.                 map[i][j].type = YELLOW;
    82.             }
    83.         }
    84.     }
    85.  
    86. }

    看上述程序:

    首先先加载出棋盘背景,然后把棋盘上面行和列交叉的位置都设置为SPACE,可以理解为初始化棋盘.然后如果j<=4,也就是楚河的一侧,我们定义棋子type全部都为黑色,而棋子的id要根据行列的位置来确定,首先看第一行,前5列数据,是不是应该是"車,馬,象,士,将"而后四列数据,是不是应该是前面去除将的反序,而观察一下,如果把前面定义成i列,后面对应相等的字符则是8-i列.那么我们就定义完了第一行的数据.

    而炮和兵的数据,以及红方的数据是不是同上述思路一样.

    然后就开始定义每一个棋子初始化的状态,回溯到棋子的基本信息结构当中,有x,y,river,type和id,我们要依次对其进行定义,

    注意在初始状态的时候,棋子的river都为false,因为都没有过楚河

    定义完棋子的位置,那么剩下没有棋子的位置,我们是不是要把刚开始初始化的状态都修改为棋盘的背景颜色啊.上述定义完,再次输出棋盘

    1. void  qiban()
    2. {
    3.     loadimage(&img, "D:/program/Project3-chess successful/1.png");
    4.     initgraph(img.getwidth(), img.getheight(), 1);
    5.     putimage(0, 0, &img);//输出棋盘
    6. }

    这个时候就已经初始化了中国象棋的棋盘.

    接下来是不是要把每一个棋子都定义到棋盘上面.开始绘画棋子

    1. void getbackground() //画棋子
    2. {
    3.     int x_start, y_start;
    4.     x_start = distance;
    5.     y_start = distance;
    6.  
    7.     settextstyle(30, 0, "黑体");//棋子大小颜色
    8.     setbkmode(0);
    9.     for (int i = 0; i <= 8; i++)
    10.     {
    11.  
    12.         for (int j = 0; j <= 9; j++)
    13.         {
    14.  
    15.             if (map[i][j].id != SPACE)//在棋盘上输出
    16.             {
    17.                 setfillcolor(RGB(253, 216, 161));
    18.                 //    setlinestyle(BLACK);
    19.                 settextcolor(map[i][j].type);
    20.                 fillcircle(map[i][j].x, map[i][j].y, 24);
    21.                 fillcircle(map[i][j].x, map[i][j].y, 18);
    22.                 outtextxy(map[i][j].x - 13, map[i][j].y - 13, chessname[map[i][j].id]);
    23.  
    24.             }
    25.         }
    26.     }
    27.  
    28. }

    如果上面棋盘行列之间的id不是SPACE,那自然就是我们定义的棋子应该安置的位置.从第0行第0列开始,依次进行定义:

    画一个棋子,两个圆环,其颜色要画成背景颜色,而棋子上面的文本颜色要根据实际行列定义的type,设置成黑色和红色,

    最后便是采用outtextxy()把每一个棋子的字符输入进行.注意此处根据棋盘x和y的地址均减13,是根据实际调试来进行,并不是确定常量.

    写到这里,是不是就把棋子和棋盘都初始化好了?yes,of course.

    3.棋盘棋子都初始化好了,那么接下来我们是不是就可以开始移动棋盘上面的棋子,进行下棋了?

    这里有一个有意思的思考:我刚开始认为吃掉棋子和走到空白的地方是两种不同的情况,后面仔细思考了一下,是同一状态,只需要把原来的修改为结束的就可以了,而原来的只需要位置只需要修改颜色和id为空也就没了,不管他end地址有没有棋子.

    1. void movechess(int a, int b, int c, int d)//移动棋子，改变其坐标
    2. {
    3.  
    4.     map[c][d].id = map[a][b].id;
    5.     map[c][d].river = map[a][b].river;
    6.     map[c][d].type = map[a][b].type;
    7.     map[c][d].x = xx(c);
    8.     map[c][d].y = yy(d);
    9.     map[a][b].id = SPACE;
    10.     map[a][b].type = YELLOW;
    11.  
    12.  
    13. }
    1. int  xx(int a)//数组下标转换成坐标
    2. {
    3.     a = distance + longth * a;
    4.     return a;
    5. }
    6. int  yy(int a)
    7. {
    8.     a = distance + high * a;
    9.     return a;
    10. }

    把[a][b]位置的棋子信息,全部给了[c][d]位置处的棋子,而[a][b]棋子此处的信息要记得修改id和type,id设置为空,而颜色设置成背景颜色.而xx(c),yy(d)就成了棋子移动到下一个点的坐标

    1. void MouseControl()//获取鼠标点击信息并完响应
    2. {
    3.     //getbackground();
    4.     if (MouseHit())
    5.     {
    6.  
    7.         float beginrow, beginrol, endrow, endrol;//第一次按下时的坐标
    8.         int intbeginrow, intbeginrol, intendrow, intendrol;//第二次按下时的坐标
    9.         MOUSEMSG msg = GetMouseMsg();/*这个函数用于获取一个鼠标消息。如果当前鼠标消息队列中没有，就一直等待。*/
    10.         if (msg.uMsg == WM_LBUTTONDOWN)//按下鼠标左键时
    11.         {
    12.             //获取鼠标点击的数组的下标
    13.         //    printf("(%d,%d)", msg.x, msg.y);
    14.             //回溯转换成行列
    15.             beginrow = (float)(msg.x - distance) / longth;
    16.             beginrol = (float)(msg.y - distance) / high;
    17.  
    18.             intbeginrow = round(beginrow);
    19.             intbeginrol = round(beginrol);
    20.  
    21.             if (moving.state == BEGIN)
    22.             {
    23.                 moving.state = END;
    24.                 moving.beginx = intbeginrow;
    25.                 moving.beginy = intbeginrol;
    26.                 //    printf("(%d,%d)  \n", moving.beginx, moving.beginy);
    27.             }
    28.             else if (moving.state == END)
    29.             {
    30.  
    31.                 moving.state = BEGIN;
    32.                 moving.endx = intbeginrow;
    33.                 moving.endy = intbeginrol;
    34.  
    35.                 execute(moving.beginx, moving.beginy, moving.endx, moving.endy);
    36.  
    37.  
    38.             }
    39.  
    40.  
    41.         }
    42.  
    43.     }
    44.  
    45. }

     上面这一段我其实有一点不清晰,我所理解的应该是定义了两个状态,如果状态是开始的时候,那状态改为结束,然后把第一次点击的数据给了开始的数据,如果状态是结束,把状态修改为开始,把第一次点击的数据给了结束的坐标.

    关键:

    1.             intbeginrow = round(beginrow);
    2.             intbeginrol = round(beginrol);

    判断输赢:

    1. int  win()
    2. {
    3.     int redgeneral = 0;
    4.     int blackgeneral = 0;
    5.     for (int i = 0; i <= 8; i++)
    6.     {
    7.         for (int j = 0; j <= 9; j++)
    8.         {
    9.             if (map[i][j].id == blackchess[4])
    10.             {
    11.                 blackgeneral++;
    12.             }
    13.             else if (map[i][j].id == redchess[4])
    14.             {
    15.                 redgeneral++;
    16.             }
    17.             else
    18.             {
    19.                 blackgeneral = blackgeneral;
    20.                 redgeneral = redgeneral;
    21.             }
    22.         }
    23.     }
    24.  
    25.     //printf("%d %d\n", blackgeneral, redgeneral);
    26.  
    27.     if (blackgeneral == 0)//红方胜
    28.     {
    29.         return 0;
    30.  
    31.     }
    32.     else if (redgeneral == 0)//黑方胜
    33.     {
    34.  
    35.         return 1;
    36.     }
    37.     else//打平
    38.     {
    39.         return 2;
    40.     }
    41.  
    42.  
    43. }

    给将和帅都定义了初始值,相当于如果将死了,那就是帅赢,相反同理,而如果两者都存在,也就是1+1,那自然就是平手,return 2;

    下面就是判断每一种棋子是否按游戏规则进行移动:

    1. bool jiang(int a, int b, int  c, int d)//判断是否只移动了一格(将军、兵的规则）
    2. {
    3.  
    4.     float h;
    5.     h = sqrt(abs(d - b) * abs(d - b) + abs(c - a) * abs(c - a));
    6.     if (b < 4 && c > 2 && c < 6 && d < 3)
    7.     {
    8.         if (h == 1 && map[c][d].type != map[a][b].type)
    9.             return true;
    10.         else
    11.             return false;
    12.     }
    13.     if (b > 4 && c > 2 && c < 6 && d >6)
    14.     {
    15.         if (h == 1 && map[c][d].type != map[a][b].type)
    16.             return true;
    17.         else
    18.             return false;
    19.     }
    20.     else
    21.     {
    22.         return false;
    23.     }
    24.  
    25. }
    26. bool bing(int a, int b, int c, int d)
    27. {
    28.     float h;
    29.     h = sqrt(abs(d - b) * abs(d - b) + abs(c - a) * abs(c - a));
    30.     if (map[a][b].type == BLACK)
    31.     {
    32.         if (map[a][b].river == false)
    33.         {
    34.             if (d == b + 1 && h == 1 && map[c][d].type != map[a][b].type)
    35.             {
    36.                 return true;
    37.  
    38.             }
    39.             else
    40.             {
    41.                 return false;
    42.             }
    43.         }
    44.         else
    45.         {
    46.             if (d >= b && h == 1 && map[c][d].type != map[a][b].type)
    47.             {
    48.                 return true;
    49.  
    50.             }
    51.             else
    52.             {
    53.                 return false;
    54.             }
    55.         }
    56.     }
    57.     else if (map[a][b].type == RED)
    58.     {
    59.         if (map[a][b].river == false)
    60.         {
    61.             if (d == b - 1 && h == 1 && map[c][d].type != map[a][b].type)
    62.             {
    63.                 return true;
    64.  
    65.             }
    66.             else
    67.             {
    68.                 return false;
    69.             }
    70.         }
    71.         else
    72.         {
    73.             if (d <= b && h == 1 && map[c][d].type != map[a][b].type)
    74.             {
    75.                 return true;
    76.  
    77.             }
    78.             else
    79.             {
    80.                 return false;
    81.             }
    82.         }
    83.     }
    84.     else
    85.     {
    86.         return false;
    87.     }
    88. }
    89. bool pao(int a, int b, int c, int d)//炮的移动
    90. {
    91.     if (c == a && d != b)
    92.     {
    93.         int time = 0;
    94.         int max = d > b ? d : b;
    95.         int min = b < d ? b : d;
    96.         for (int i = min; i <= max; i++)
    97.         {
    98.             if (map[c][i].id != SPACE)
    99.             {
    100.                 time++;
    101.             }
    102.  
    103.         }
    104.         //    printf("%d\n", time);
    105.         if (map[c][d].id == SPACE)
    106.         {
    107.             if (time == 1)
    108.                 return  true;
    109.             else
    110.                 return false;
    111.         }
    112.         if (map[c][d].id != SPACE)
    113.         {
    114.  
    115.             if (time != 3)
    116.             {
    117.                 return false;
    118.             }
    119.             else
    120.             {
    121.                 if (map[c][d].type == map[a][b].type)
    122.                 {
    123.                     return false;
    124.                 }
    125.                 else
    126.                 {
    127.                     return true;
    128.                 }
    129.             }
    130.  
    131.  
    132.         }
    133.  
    134.     }
    135.     else if (d == b && c != a)
    136.     {
    137.         int time = 0;
    138.         int max = a > c ? a : c;
    139.         int min = c < a ? c : a;
    140.         for (int i = min; i <= max; i++)
    141.         {
    142.             if (map[i][d].id != SPACE)
    143.             {
    144.                 time++;
    145.             }
    146.         }
    147.         //    printf("%d\n", time);
    148.         if (map[c][d].id == SPACE)
    149.         {
    150.             if (time == 1)
    151.                 return  true;
    152.             else
    153.                 return false;
    154.         }
    155.         if (map[c][d].id != SPACE)
    156.         {
    157.  
    158.             if (time != 3)
    159.             {
    160.                 return false;
    161.             }
    162.             else
    163.             {
    164.                 if (map[c][d].type == map[a][b].type)
    165.                 {
    166.                     return false;
    167.                 }
    168.                 else
    169.                 {
    170.                     return true;
    171.                 }
    172.             }
    173.  
    174.  
    175.         }
    176.     }
    177.     else
    178.     {
    179.         return false;
    180.     }
    181. }
    182. bool che(int a, int b, int c, int d)
    183. {
    184.  
    185.     if (c == a && d != b)//是否为直线
    186.     {
    187.  
    188.         int time = 0;
    189.         int max = d > b ? d : b;
    190.         int min = b < d ? b : d;
    191.         for (int i = min; i <= max; i++)//遍历路径
    192.         {
    193.  
    194.  
    195.             if (map[c][i].id != SPACE)
    196.             {
    197.                 time++;
    198.             }
    199.  
    200.  
    201.         }
    202.         //    printf("%d", time);
    203.         if (time == 1)//车移动不吃棋子
    204.         {
    205.             return true;
    206.  
    207.         }
    208.         if (time == 2)//车移动并且吃目的坐标的棋子
    209.         {
    210.             if (map[c][d].type == map[a][b].type)//如果是目的坐标是自己的棋子，则返回false
    211.             {
    212.                 return false;
    213.             }
    214.             if (map[c][d].type == YELLOW)
    215.             {
    216.                 return false;
    217.             }
    218.             else
    219.             {
    220.                 return true;
    221.             }
    222.         }
    223.         else
    224.         {
    225.             return false;
    226.         }
    227.     }
    228.     else    if (d == b && c != a)
    229.     {
    230.         int time = 0;
    231.         int max = c > a ? c : a;
    232.         int min = a < c ? a : c;
    233.         for (int i = min; i <= max; i++)//遍历路径
    234.         {
    235.             if (map[i][d].id != SPACE)
    236.             {
    237.                 time++;
    238.             }
    239.  
    240.         }
    241.         //    printf("%d", time);
    242.         if (time == 1)//车是否车跳棋
    243.         {
    244.             return true;
    245.         }
    246.         else if (time == 2)
    247.         {
    248.             if (map[c][d].type == map[a][b].type)
    249.             {
    250.                 return false;
    251.             }
    252.             if (map[c][d].type == YELLOW)
    253.             {
    254.                 return false;
    255.             }
    256.             else
    257.             {
    258.                 return true;
    259.             }
    260.         }
    261.         else
    262.         {
    263.             return false;
    264.         }
    265.     }
    266.     else
    267.     {
    268.         return 0;
    269.     }
    270. }
    271. bool ma(int a, int b, int c, int d)
    272. {
    273.     float h;
    274.     h = sqrt(abs(d - b) * abs(d - b) + abs(c - a) * abs(c - a));
    275.     //    printf("%f", h);
    276.     if (h <= 2 || h >= 2.5)//根号8=2.8.根号5=2.2
    277.     {
    278.         //    printf("太远了！\n");
    279.         return  false;
    280.     }
    281.     else
    282.     {
    283.         int xx, yy, max, min;//关键点的坐标和中间值
    284.         max = abs(d - b) > abs(c - a) ? abs(d - b) : abs(c - a);
    285.         min = abs(c - a) < abs(d - b) ? abs(c - a) : abs(d - b);
    286.         //printf("max\min:(%d,%d)", max, min);
    287.         if (max == abs(d - b))
    288.         {
    289.             yy = b + (d - b) / 2;
    290.             xx = a;
    291.         }
    292.         else
    293.         {
    294.             xx = a + (c - a) / 2;
    295.             yy = b;
    296.         }
    297.         //    printf("xx\yy:(%d,%d)\n", xx, yy);
    298.         if (map[xx][yy].id == SPACE)
    299.         {
    300.             if (map[c][d].type != map[a][b].type)
    301.             {
    302.                 //    printf("目的坐标（%d,%d）\n", c, d);
    303.                 //    printf("那是你自己的棋子！\n");
    304.                 return true;
    305.             }
    306.             else
    307.             {
    308.                 //    printf("那是你的棋子！\n");
    309.                 return false;
    310.             }
    311.  
    312.         }
    313.         else
    314.         {
    315.             //    printf("关键位置有棋子！\n");
    316.             return false;
    317.         }
    318.     }
    319. }
    320. bool xiang(int a, int b, int c, int d)
    321. {
    322.  
    323.     float h;
    324.     h = sqrt(abs(d - b) * abs(d - b) + abs(c - a) * abs(c - a));
    325.     if (b <= 4)
    326.     {
    327.         if (d > 4)
    328.         {
    329.             return false;
    330.         }
    331.         else
    332.         {
    333.             if (h < 2.4 || h>2.9)
    334.             {
    335.                 return false;
    336.             }
    337.             else
    338.             {
    339.                 int xx = (a + c) / 2;
    340.                 int yy = (b + d) / 2;
    341.                 if (map[xx][yy].id == SPACE)
    342.                 {
    343.                     if (map[c][d].type == map[a][b].type)
    344.                     {
    345.                         return false;
    346.                     }
    347.                     else
    348.                     {
    349.                         return true;
    350.  
    351.                     }
    352.                 }
    353.                 else
    354.                 {
    355.                     return false;
    356.                 }
    357.             }
    358.         }
    359.  
    360.     }
    361.     else
    362.     {
    363.         if (d < 5)
    364.         {
    365.             return false;
    366.         }
    367.         else
    368.         {
    369.             if (h < 2.4 || h>2.9)
    370.             {
    371.                 return false;
    372.             }
    373.             else
    374.             {
    375.                 int xx = (a + c) / 2;
    376.                 int yy = (b + d) / 2;
    377.                 if (map[xx][yy].id == SPACE)
    378.                 {
    379.                     if (map[c][d].type == map[a][b].type)
    380.                     {
    381.                         return false;
    382.                     }
    383.                     else
    384.                     {
    385.                         return true;
    386.  
    387.                     }
    388.                 }
    389.                 else
    390.                 {
    391.                     return false;
    392.                 }
    393.             }
    394.         }
    395.     }
    396.  
    397.  
    398. }
    399. bool shi(int a, int b, int c, int d)
    400. {
    401.     float h = sqrt(abs(d - b) * abs(d - b) + abs(c - a) * abs(c - a));
    402.     //  printf("%f", h)
    403.  
    404.     if (b < 5)
    405.     {
    406.         if (c >= 3 && c <= 5 && d <= 2)
    407.         {
    408.  
    409.             if (1.2 < h && h < 1.5)
    410.             {
    411.                 if (map[c][d].type != map[a][b].type)
    412.                     return true;
    413.                 else
    414.                     return false;
    415.  
    416.             }
    417.             else
    418.             {
    419.                 return false;
    420.             }
    421.         }
    422.         else
    423.         {
    424.             return false;
    425.         }
    426.     }
    427.     else if (b > 5)
    428.     {
    429.         if (c >= 3 && c <= 5 && d >= 7)
    430.         {
    431.  
    432.             if (1.2 < h && h < 1.5)
    433.             {
    434.                 if (map[c][d].type != map[a][b].type)
    435.                     return true;
    436.                 else
    437.                     return false;
    438.  
    439.             }
    440.             else
    441.             {
    442.                 return false;
    443.             }
    444.         }
    445.         else
    446.         {
    447.             return false;
    448.         }
    449.     }
    450.     else
    451.         return false;
    452. }

    上述全都是bool型,用以表示判断是否正确就行

    接下来是行棋子,如果遵守规则,也就是上面的bool输出true,则移动,否则输出"你不能这样做!"

    1. void execute(int a, int b, int c, int d)//行棋
    2. {
    3.     if (map[a][b].id == blackchess[4])//黑方将
    4.     {
    5.         if (jiang(a, b, c, d))
    6.         {
    7.  
    8.             movechess(a, b, c, d);
    9.  
    10.         }
    11.         else
    12.         {
    13.             printf("你不能这样做\n");
    14.         }
    15.  
    16.     }
    17.     else if (map[a][b].id == redchess[4])//红方将
    18.     {
    19.  
    20.         if (jiang(a, b, c, d))
    21.         {
    22.             movechess(a, b, c, d);
    23.         }
    24.         else
    25.         {
    26.             printf("你不能这样做!\n");
    27.         }
    28.     }
    29.  
    30.     else if (map[a][b].id == blackchess[6])//黑方兵
    31.     {
    32.         if (map[a][b].river == false)
    33.         {
    34.             if (bing(a, b, c, d))
    35.             {
    36.                 movechess(a, b, c, d);
    37.  
    38.                 if (d > 4)
    39.                 {
    40.                     map[c][d].river = true;
    41.                 }
    42.             }
    43.             else
    44.             {
    45.                 printf("你不可以这样做！\n");
    46.             }
    47.         }
    48.         else
    49.         {
    50.             if (bing(a, b, c, d) && d >= b)
    51.             {
    52.                 movechess(a, b, c, d);
    53.  
    54.             }
    55.             else
    56.             {
    57.                 printf("你不可以这样做\n");
    58.             }
    59.         }
    60.     }
    61.     else if (map[a][b].id == redchess[6])//红方兵
    62.     {
    63.         if (map[a][b].river == false)
    64.         {
    65.             if (bing(a, b, c, d))
    66.             {
    67.                 movechess(a, b, c, d);
    68.  
    69.                 if (d < 5)
    70.                 {
    71.                     map[c][d].river = true;
    72.                 }
    73.             }
    74.             else
    75.             {
    76.                 printf("你不可以这样做！\n");
    77.             }
    78.         }
    79.         else
    80.         {
    81.             if (bing(a, b, c, d) && d <= b)
    82.             {
    83.                 movechess(a, b, c, d);
    84.  
    85.             }
    86.             else
    87.             {
    88.                 printf("你不可以这样做!\n");
    89.             }
    90.         }
    91.     }
    92.     else if (map[a][b].id == blackchess[5] || map[a][b].id == redchess[5])
    93.     {
    94.         if (pao(a, b, c, d))
    95.         {
    96.             movechess(a, b, c, d);
    97.  
    98.         }
    99.         else
    100.         {
    101.             printf("你不能这样做！\n");
    102.         }
    103.  
    104.     }
    105.     else if (map[a][b].id == blackchess[0] || map[a][b].id == redchess[0])
    106.     {
    107.         if (che(a, b, c, d))
    108.         {
    109.             movechess(a, b, c, d);
    110.  
    111.         }
    112.         else
    113.         {
    114.             printf("你不可以这样做！\n");
    115.         }
    116.     }
    117.     else if (map[a][b].id == blackchess[1] || map[a][b].id == redchess[1])
    118.     {
    119.  
    120.  
    121.         if (ma(a, b, c, d))
    122.         {
    123.             movechess(a, b, c, d);
    124.  
    125.  
    126.         }
    127.         else
    128.         {
    129.             printf("你不能这样做！\n");
    130.         }
    131.  
    132.     }
    133.     else if (map[a][b].id == blackchess[2] || map[a][b].id == redchess[2])
    134.     {
    135.         if (xiang(a, b, c, d))
    136.         {
    137.             movechess(a, b, c, d);
    138.  
    139.         }
    140.         else
    141.             printf("你不能这样做！\n");
    142.  
    143.     }
    144.     else if (map[a][b].id == blackchess[3])
    145.     {
    146.         if (shi(a, b, c, d))
    147.         {
    148.             movechess(a, b, c, d);
    149.  
    150.         }
    151.         else
    152.             printf("你不能这样做！");
    153.     }
    154.     else if (map[a][b].id == redchess[3])
    155.     {
    156.         if (shi(a, b, c, d))
    157.         {
    158.             movechess(a, b, c, d);
    159.  
    160.         }
    161.         else
    162.             printf("你不能这样做！");
    163.     }
    164. }

    定义完上面所有的函数,最后就是主函数,运行就可以了

    1. int main()
    2. {
    3.     begining();
    4.     while (1)//当正确的时候
    5.     {
    6.         coord();//输出棋盘
    7.         win();
    8.         BeginBatchDraw();
    9.         /*这个函数用于开始批量绘图。执行后
    10.         任何绘图操作都将暂时不输出到绘图窗口上，直到执行 FlushBatchDraw 或 EndBatchDraw 才将之前的绘图输出。*/
    11.         //运行BeginBatchDraw后，所有的绘图都不再显示在屏幕上，而是在内存中进行
    12.         //封装的双缓存,避免闪屏
    13.         /*那如果我们能让打印的过程不显示出来，只显示打印完后的显示缓冲区不就行了吗*/
    14.         while (win() == 2)//平局状态,是不是还需要继续运行下去?
    15.         {
    16.             win();
    17.             putimage(0, 0, &img);
    18.             getbackground();//输出棋子
    19.             MouseControl();//鼠标更改数据
    20.             FlushBatchDraw();/*这个函数用于执行未完成的绘制任务。*/
    21.  
    22.         }
    23.  
    24.         putimage(0, 0, &img);
    25.         getbackground();//输出棋子
    26.         MouseControl();//鼠标更改数据
    27.         FlushBatchDraw();/*这个函数用于执行未完成的绘制任务。*/
    28.         if (win() == 0)
    29.         {
    30.             printf("红方胜！\n");
    31.         }
    32.         else if (win() == 1)
    33.         {
    34.             printf("黑方胜！\n");
    35.  
    36.         }
    37.     }
    38.     getchar();
    39.  
    40.     return 0;
    41. }

    总代码:

    1. #include<stdio.h>
    2. #include<graphics.h>
    3. #include<math.h>
    4. void execute(int a, int b, int c, int d);
    5. bool jiang(int a, int b, int  c, int d);
    6. bool pao(int a, int b, int c, int d);
    7. bool ma(int a, int b, int c, int d);
    8. IMAGE img;
    9. #define distance  35//窗口线与棋盘边界线的距离
    10. #define   longth  65//棋盘方格的长
    11. #define   high   61//棋盘方格的宽
    12. struct movecoordinate
    13. {
    14.     long x;
    15.     long y;
    16. };
    17. struct  Chesscoordinate//棋子综合信息
    18. {
    19.     int x;
    20.     int y;
    21.     DWORD type;  //颜色
    22.     bool river;//是否过河
    23.     int id;
    24. };
    25. enum pieces
    26. {
    27.     SPACE = -1,
    28.     車, 馬, 象, 士, 将, 炮, 卒,
    29.     车, 马, 相, 仕, 帥, 砲, 兵,
    30.     BEGIN, END,
    31.  
    32. };
    33. enum pieces redchess[] = { 車,馬,象,士,将,炮,卒, };
    34. enum pieces blackchess[] = { 车,马,相,仕,帥,砲,兵, };
    35. enum pieces state = BEGIN;
    36. struct move {  //鼠标选中的棋子
    37.     int beginx;
    38.     int beginy;
    39.     int endx;
    40.     int endy;
    41.     int state;
    42. }moving = { -1,-1,-1,-1,BEGIN };
    43. const char* chessname[] = { "車","馬","象","士","将","炮","卒","车","马","相","仕","帥","砲","兵", };
    44. struct Chesscoordinate  map[9][10];//坐标
    45. struct Chesscoordinate  AImap[9][10];//坐标
    46. movecoordinate begin = { -1,-1 }, end = { -1,-1 };
    47. int  xx(int a)//数组下标转换成坐标
    48. {
    49.     a = distance + longth * a;
    50.     return a;
    51. }
    52. int  yy(int a)
    53. {
    54.     a = distance + high * a;
    55.     return a;
    56. }
    57. void begining()
    58. {
    59.     loadimage(&img, "D:/program/Project3-chess successful/1.png");
    60.     initgraph(img.getwidth(), img.getheight(), 1); //初始化图形系统
    61.     putimage(0, 0, &img);//输出开始界面；
    62.  
    63. }
    64. void  qiban()
    65. {
    66.     loadimage(&img, "D:/program/Project3-chess successful/1.png");
    67.     initgraph(img.getwidth(), img.getheight(), 1);
    68.     putimage(0, 0, &img);//输出棋盘
    69. }
    70. void  coord()//棋子信息赋值
    71. {
    72.     loadimage(&img, "D:/program/Project3-chess successful/1.png");
    73.     putimage(0, 0, &img);//输出棋盘
    74.  
    75.     for (int i = 0; i <= 8; i++)
    76.     {
    77.  
    78.         for (int j = 0; j <= 9; j++)//遍历二维数组
    79.         {
    80.             enum pieces chessid = SPACE;//先把全部位置的id赋值为SAPCE
    81.             DWORD  chesstype;//定义颜色中间变量
    82.             if (j <= 4)
    83.             {
    84.                 chesstype = BLACK;//黑方
    85.                 if (j == 0)
    86.                 {
    87.                     if (i <= 4)
    88.                     {
    89.                         chessid = blackchess[i];//
    90.                     }
    91.                     else
    92.                     {
    93.                         chessid = blackchess[8 - i];
    94.                     }
    95.  
    96.                 }
    97.                 if (j == 2 && (i == 1 || i == 7))
    98.                 {
    99.                     chessid = blackchess[5];
    100.  
    101.                 }
    102.  
    103.                 if (j == 3 && (i == 0 || i == 2 || i == 4 || i == 4 || i == 6 || i == 8))
    104.                 {
    105.                     chessid = blackchess[6];
    106.                 }
    107.  
    108.             }
    109.             else
    110.             {
    111.                 chesstype = RED;//红方
    112.                 if (j == 6 && (i == 0 || i == 2 || i == 4 || i == 6 || i == 8))
    113.                 {
    114.                     chessid = redchess[6];
    115.                 }
    116.                 if (j == 7 && (i == 1 || i == 7))
    117.                 {
    118.                     chessid = redchess[5];
    119.  
    120.                 }
    121.  
    122.                 if (j == 9)
    123.                 {
    124.  
    125.                     if (i <= 4)
    126.                     {
    127.                         chessid = redchess[i];
    128.                     }
    129.                     else
    130.                     {
    131.                         chessid = redchess[8 - i];
    132.                     }
    133.                 }
    134.  
    135.             }//依次赋值
    136.             map[i][j].id = chessid;
    137.             map[i][j].river = false;
    138.             map[i][j].type = chesstype;
    139.             map[i][j].x = distance + longth * i;
    140.             map[i][j].y = distance + high * j;
    141.  
    142.         }
    143.     }
    144.     for (int i = 0; i <= 8; i++)
    145.     {
    146.         for (int j = 0; j <= 9; j++)
    147.         {
    148.             if (map[i][j].id == SPACE)
    149.             {
    150.                 map[i][j].type = YELLOW;
    151.             }
    152.         }
    153.     }
    154.  
    155. }
    156. void getbackground() //画棋子
    157. {
    158.     int x_start, y_start;
    159.     x_start = distance;
    160.     y_start = distance;
    161.  
    162.     settextstyle(30, 0, "黑体");//棋子大小颜色
    163.     setbkmode(0);
    164.     for (int i = 0; i <= 8; i++)
    165.     {
    166.  
    167.         for (int j = 0; j <= 9; j++)
    168.         {
    169.  
    170.             if (map[i][j].id != SPACE)//在棋盘上输出
    171.             {
    172.                 setfillcolor(RGB(253, 216, 161));
    173.                 //    setlinestyle(BLACK);
    174.                 settextcolor(map[i][j].type);
    175.                 fillcircle(map[i][j].x, map[i][j].y, 24);
    176.                 fillcircle(map[i][j].x, map[i][j].y, 18);
    177.                 outtextxy(map[i][j].x - 13, map[i][j].y - 13, chessname[map[i][j].id]);
    178.  
    179.             }
    180.         }
    181.     }
    182.  
    183. }
    184. void movechess(int a, int b, int c, int d)//移动棋子，改变其坐标
    185. {
    186.  
    187.     map[c][d].id = map[a][b].id;
    188.     map[c][d].river = map[a][b].river;
    189.     map[c][d].type = map[a][b].type;
    190.     map[c][d].x = xx(c);
    191.     map[c][d].y = yy(d);
    192.     map[a][b].id = SPACE;
    193.     map[a][b].type = YELLOW;
    194.  
    195.  
    196. }
    197.  
    198. void MouseControl()//获取鼠标点击信息并完响应
    199. {
    200.     //getbackground();
    201.     if (MouseHit())
    202.     {
    203.  
    204.         float beginrow, beginrol, endrow, endrol;//第一次按下时的坐标
    205.         int intbeginrow, intbeginrol, intendrow, intendrol;//第二次按下时的坐标
    206.         MOUSEMSG msg = GetMouseMsg();/*这个函数用于获取一个鼠标消息。如果当前鼠标消息队列中没有，就一直等待。*/
    207.         if (msg.uMsg == WM_LBUTTONDOWN)//按下鼠标左键时
    208.         {
    209.             //获取鼠标点击的数组的下标
    210.         //    printf("(%d,%d)", msg.x, msg.y);
    211.             //回溯转换成行列
    212.             beginrow = (float)(msg.x - distance) / longth;
    213.             beginrol = (float)(msg.y - distance) / high;
    214.  
    215.             intbeginrow = round(beginrow);
    216.             intbeginrol = round(beginrol);
    217.  
    218.             if (moving.state == BEGIN)
    219.             {
    220.                 moving.state = END;
    221.                 moving.beginx = intbeginrow;
    222.                 moving.beginy = intbeginrol;
    223.                 //    printf("(%d,%d)  \n", moving.beginx, moving.beginy);
    224.             }
    225.             else if (moving.state == END)
    226.             {
    227.  
    228.                 moving.state = BEGIN;
    229.                 moving.endx = intbeginrow;
    230.                 moving.endy = intbeginrol;
    231.  
    232.                 execute(moving.beginx, moving.beginy, moving.endx, moving.endy);
    233.  
    234.  
    235.             }
    236.  
    237.  
    238.         }
    239.  
    240.     }
    241.  
    242. }
    243.  
    244.  
    245. int  win()
    246. {
    247.     int redgeneral = 0;
    248.     int blackgeneral = 0;
    249.     for (int i = 0; i <= 8; i++)
    250.     {
    251.         for (int j = 0; j <= 9; j++)
    252.         {
    253.             if (map[i][j].id == blackchess[4])
    254.             {
    255.                 blackgeneral++;
    256.             }
    257.             else if (map[i][j].id == redchess[4])
    258.             {
    259.                 redgeneral++;
    260.             }
    261.             else
    262.             {
    263.                 blackgeneral = blackgeneral;
    264.                 redgeneral = redgeneral;
    265.             }
    266.         }
    267.     }
    268.  
    269.     //printf("%d %d\n", blackgeneral, redgeneral);
    270.  
    271.     if (blackgeneral == 0)//红方胜
    272.     {
    273.         return 0;
    274.  
    275.     }
    276.     else if (redgeneral == 0)//黑方胜
    277.     {
    278.  
    279.         return 1;
    280.     }
    281.     else//打平
    282.     {
    283.         return 2;
    284.     }
    285.  
    286.  
    287. }
    288. bool jiang(int a, int b, int  c, int d)//判断是否只移动了一格(将军、兵的规则）
    289. {
    290.  
    291.     float h;
    292.     h = sqrt(abs(d - b) * abs(d - b) + abs(c - a) * abs(c - a));
    293.     if (b < 4 && c > 2 && c < 6 && d < 3)
    294.     {
    295.         if (h == 1 && map[c][d].type != map[a][b].type)
    296.             return true;
    297.         else
    298.             return false;
    299.     }
    300.     if (b > 4 && c > 2 && c < 6 && d >6)
    301.     {
    302.         if (h == 1 && map[c][d].type != map[a][b].type)
    303.             return true;
    304.         else
    305.             return false;
    306.     }
    307.     else
    308.     {
    309.         return false;
    310.     }
    311.  
    312. }
    313. bool bing(int a, int b, int c, int d)
    314. {
    315.     float h;
    316.     h = sqrt(abs(d - b) * abs(d - b) + abs(c - a) * abs(c - a));
    317.     if (map[a][b].type == BLACK)
    318.     {
    319.         if (map[a][b].river == false)
    320.         {
    321.             if (d == b + 1 && h == 1 && map[c][d].type != map[a][b].type)
    322.             {
    323.                 return true;
    324.  
    325.             }
    326.             else
    327.             {
    328.                 return false;
    329.             }
    330.         }
    331.         else
    332.         {
    333.             if (d >= b && h == 1 && map[c][d].type != map[a][b].type)
    334.             {
    335.                 return true;
    336.  
    337.             }
    338.             else
    339.             {
    340.                 return false;
    341.             }
    342.         }
    343.     }
    344.     else if (map[a][b].type == RED)
    345.     {
    346.         if (map[a][b].river == false)
    347.         {
    348.             if (d == b - 1 && h == 1 && map[c][d].type != map[a][b].type)
    349.             {
    350.                 return true;
    351.  
    352.             }
    353.             else
    354.             {
    355.                 return false;
    356.             }
    357.         }
    358.         else
    359.         {
    360.             if (d <= b && h == 1 && map[c][d].type != map[a][b].type)
    361.             {
    362.                 return true;
    363.  
    364.             }
    365.             else
    366.             {
    367.                 return false;
    368.             }
    369.         }
    370.     }
    371.     else
    372.     {
    373.         return false;
    374.     }
    375. }
    376. bool pao(int a, int b, int c, int d)//炮的移动
    377. {
    378.     if (c == a && d != b)
    379.     {
    380.         int time = 0;
    381.         int max = d > b ? d : b;
    382.         int min = b < d ? b : d;
    383.         for (int i = min; i <= max; i++)
    384.         {
    385.             if (map[c][i].id != SPACE)
    386.             {
    387.                 time++;
    388.             }
    389.  
    390.         }
    391.         //    printf("%d\n", time);
    392.         if (map[c][d].id == SPACE)
    393.         {
    394.             if (time == 1)
    395.                 return  true;
    396.             else
    397.                 return false;
    398.         }
    399.         if (map[c][d].id != SPACE)
    400.         {
    401.  
    402.             if (time != 3)
    403.             {
    404.                 return false;
    405.             }
    406.             else
    407.             {
    408.                 if (map[c][d].type == map[a][b].type)
    409.                 {
    410.                     return false;
    411.                 }
    412.                 else
    413.                 {
    414.                     return true;
    415.                 }
    416.             }
    417.  
    418.  
    419.         }
    420.  
    421.     }
    422.     else if (d == b && c != a)
    423.     {
    424.         int time = 0;
    425.         int max = a > c ? a : c;
    426.         int min = c < a ? c : a;
    427.         for (int i = min; i <= max; i++)
    428.         {
    429.             if (map[i][d].id != SPACE)
    430.             {
    431.                 time++;
    432.             }
    433.         }
    434.         //    printf("%d\n", time);
    435.         if (map[c][d].id == SPACE)
    436.         {
    437.             if (time == 1)
    438.                 return  true;
    439.             else
    440.                 return false;
    441.         }
    442.         if (map[c][d].id != SPACE)
    443.         {
    444.  
    445.             if (time != 3)
    446.             {
    447.                 return false;
    448.             }
    449.             else
    450.             {
    451.                 if (map[c][d].type == map[a][b].type)
    452.                 {
    453.                     return false;
    454.                 }
    455.                 else
    456.                 {
    457.                     return true;
    458.                 }
    459.             }
    460.  
    461.  
    462.         }
    463.     }
    464.     else
    465.     {
    466.         return false;
    467.     }
    468. }
    469. bool che(int a, int b, int c, int d)
    470. {
    471.  
    472.     if (c == a && d != b)//是否为直线
    473.     {
    474.  
    475.         int time = 0;
    476.         int max = d > b ? d : b;
    477.         int min = b < d ? b : d;
    478.         for (int i = min; i <= max; i++)//遍历路径
    479.         {
    480.  
    481.  
    482.             if (map[c][i].id != SPACE)
    483.             {
    484.                 time++;
    485.             }
    486.  
    487.  
    488.         }
    489.         //    printf("%d", time);
    490.         if (time == 1)//车移动不吃棋子
    491.         {
    492.             return true;
    493.  
    494.         }
    495.         if (time == 2)//车移动并且吃目的坐标的棋子
    496.         {
    497.             if (map[c][d].type == map[a][b].type)//如果是目的坐标是自己的棋子，则返回false
    498.             {
    499.                 return false;
    500.             }
    501.             if (map[c][d].type == YELLOW)
    502.             {
    503.                 return false;
    504.             }
    505.             else
    506.             {
    507.                 return true;
    508.             }
    509.         }
    510.         else
    511.         {
    512.             return false;
    513.         }
    514.     }
    515.     else    if (d == b && c != a)
    516.     {
    517.         int time = 0;
    518.         int max = c > a ? c : a;
    519.         int min = a < c ? a : c;
    520.         for (int i = min; i <= max; i++)//遍历路径
    521.         {
    522.             if (map[i][d].id != SPACE)
    523.             {
    524.                 time++;
    525.             }
    526.  
    527.         }
    528.         //    printf("%d", time);
    529.         if (time == 1)//车是否车跳棋
    530.         {
    531.             return true;
    532.         }
    533.         else if (time == 2)
    534.         {
    535.             if (map[c][d].type == map[a][b].type)
    536.             {
    537.                 return false;
    538.             }
    539.             if (map[c][d].type == YELLOW)
    540.             {
    541.                 return false;
    542.             }
    543.             else
    544.             {
    545.                 return true;
    546.             }
    547.         }
    548.         else
    549.         {
    550.             return false;
    551.         }
    552.     }
    553.     else
    554.     {
    555.         return 0;
    556.     }
    557. }
    558. bool ma(int a, int b, int c, int d)
    559. {
    560.     float h;
    561.     h = sqrt(abs(d - b) * abs(d - b) + abs(c - a) * abs(c - a));
    562.     //    printf("%f", h);
    563.     if (h <= 2 || h >= 2.5)//根号8=2.8.根号5=2.2
    564.     {
    565.         //    printf("太远了！\n");
    566.         return  false;
    567.     }
    568.     else
    569.     {
    570.         int xx, yy, max, min;//关键点的坐标和中间值
    571.         max = abs(d - b) > abs(c - a) ? abs(d - b) : abs(c - a);
    572.         min = abs(c - a) < abs(d - b) ? abs(c - a) : abs(d - b);
    573.         //printf("max\min:(%d,%d)", max, min);
    574.         if (max == abs(d - b))
    575.         {
    576.             yy = b + (d - b) / 2;
    577.             xx = a;
    578.         }
    579.         else
    580.         {
    581.             xx = a + (c - a) / 2;
    582.             yy = b;
    583.         }
    584.         //    printf("xx\yy:(%d,%d)\n", xx, yy);
    585.         if (map[xx][yy].id == SPACE)
    586.         {
    587.             if (map[c][d].type != map[a][b].type)
    588.             {
    589.                 //    printf("目的坐标（%d,%d）\n", c, d);
    590.                 //    printf("那是你自己的棋子！\n");
    591.                 return true;
    592.             }
    593.             else
    594.             {
    595.                 //    printf("那是你的棋子！\n");
    596.                 return false;
    597.             }
    598.  
    599.         }
    600.         else
    601.         {
    602.             //    printf("关键位置有棋子！\n");
    603.             return false;
    604.         }
    605.     }
    606. }
    607. bool xiang(int a, int b, int c, int d)
    608. {
    609.  
    610.     float h;
    611.     h = sqrt(abs(d - b) * abs(d - b) + abs(c - a) * abs(c - a));
    612.     if (b <= 4)
    613.     {
    614.         if (d > 4)
    615.         {
    616.             return false;
    617.         }
    618.         else
    619.         {
    620.             if (h < 2.4 || h>2.9)
    621.             {
    622.                 return false;
    623.             }
    624.             else
    625.             {
    626.                 int xx = (a + c) / 2;
    627.                 int yy = (b + d) / 2;
    628.                 if (map[xx][yy].id == SPACE)
    629.                 {
    630.                     if (map[c][d].type == map[a][b].type)
    631.                     {
    632.                         return false;
    633.                     }
    634.                     else
    635.                     {
    636.                         return true;
    637.  
    638.                     }
    639.                 }
    640.                 else
    641.                 {
    642.                     return false;
    643.                 }
    644.             }
    645.         }
    646.  
    647.     }
    648.     else
    649.     {
    650.         if (d < 5)
    651.         {
    652.             return false;
    653.         }
    654.         else
    655.         {
    656.             if (h < 2.4 || h>2.9)
    657.             {
    658.                 return false;
    659.             }
    660.             else
    661.             {
    662.                 int xx = (a + c) / 2;
    663.                 int yy = (b + d) / 2;
    664.                 if (map[xx][yy].id == SPACE)
    665.                 {
    666.                     if (map[c][d].type == map[a][b].type)
    667.                     {
    668.                         return false;
    669.                     }
    670.                     else
    671.                     {
    672.                         return true;
    673.  
    674.                     }
    675.                 }
    676.                 else
    677.                 {
    678.                     return false;
    679.                 }
    680.             }
    681.         }
    682.     }
    683.  
    684.  
    685. }
    686. bool shi(int a, int b, int c, int d)
    687. {
    688.     float h = sqrt(abs(d - b) * abs(d - b) + abs(c - a) * abs(c - a));
    689.     //  printf("%f", h)
    690.  
    691.     if (b < 5)
    692.     {
    693.         if (c >= 3 && c <= 5 && d <= 2)
    694.         {
    695.  
    696.             if (1.2 < h && h < 1.5)
    697.             {
    698.                 if (map[c][d].type != map[a][b].type)
    699.                     return true;
    700.                 else
    701.                     return false;
    702.  
    703.             }
    704.             else
    705.             {
    706.                 return false;
    707.             }
    708.         }
    709.         else
    710.         {
    711.             return false;
    712.         }
    713.     }
    714.     else if (b > 5)
    715.     {
    716.         if (c >= 3 && c <= 5 && d >= 7)
    717.         {
    718.  
    719.             if (1.2 < h && h < 1.5)
    720.             {
    721.                 if (map[c][d].type != map[a][b].type)
    722.                     return true;
    723.                 else
    724.                     return false;
    725.  
    726.             }
    727.             else
    728.             {
    729.                 return false;
    730.             }
    731.         }
    732.         else
    733.         {
    734.             return false;
    735.         }
    736.     }
    737.     else
    738.         return false;
    739. }
    740. void execute(int a, int b, int c, int d)//行棋
    741. {
    742.     if (map[a][b].id == blackchess[4])//黑方将
    743.     {
    744.         if (jiang(a, b, c, d))
    745.         {
    746.  
    747.             movechess(a, b, c, d);
    748.  
    749.         }
    750.         else
    751.         {
    752.             printf("你不能这样做\n");
    753.         }
    754.  
    755.     }
    756.     else if (map[a][b].id == redchess[4])//红方将
    757.     {
    758.  
    759.         if (jiang(a, b, c, d))
    760.         {
    761.             movechess(a, b, c, d);
    762.         }
    763.         else
    764.         {
    765.             printf("你不能这样做!\n");
    766.         }
    767.     }
    768.  
    769.     else if (map[a][b].id == blackchess[6])//黑方兵
    770.     {
    771.         if (map[a][b].river == false)
    772.         {
    773.             if (bing(a, b, c, d))
    774.             {
    775.                 movechess(a, b, c, d);
    776.  
    777.                 if (d > 4)
    778.                 {
    779.                     map[c][d].river = true;
    780.                 }
    781.             }
    782.             else
    783.             {
    784.                 printf("你不可以这样做！\n");
    785.             }
    786.         }
    787.         else
    788.         {
    789.             if (bing(a, b, c, d) && d >= b)
    790.             {
    791.                 movechess(a, b, c, d);
    792.  
    793.             }
    794.             else
    795.             {
    796.                 printf("你不可以这样做\n");
    797.             }
    798.         }
    799.     }
    800.     else if (map[a][b].id == redchess[6])//红方兵
    801.     {
    802.         if (map[a][b].river == false)
    803.         {
    804.             if (bing(a, b, c, d))
    805.             {
    806.                 movechess(a, b, c, d);
    807.  
    808.                 if (d < 5)
    809.                 {
    810.                     map[c][d].river = true;
    811.                 }
    812.             }
    813.             else
    814.             {
    815.                 printf("你不可以这样做！\n");
    816.             }
    817.         }
    818.         else
    819.         {
    820.             if (bing(a, b, c, d) && d <= b)
    821.             {
    822.                 movechess(a, b, c, d);
    823.  
    824.             }
    825.             else
    826.             {
    827.                 printf("你不可以这样做!\n");
    828.             }
    829.         }
    830.     }
    831.     else if (map[a][b].id == blackchess[5] || map[a][b].id == redchess[5])
    832.     {
    833.         if (pao(a, b, c, d))
    834.         {
    835.             movechess(a, b, c, d);
    836.  
    837.         }
    838.         else
    839.         {
    840.             printf("你不能这样做！\n");
    841.         }
    842.  
    843.     }
    844.     else if (map[a][b].id == blackchess[0] || map[a][b].id == redchess[0])
    845.     {
    846.         if (che(a, b, c, d))
    847.         {
    848.             movechess(a, b, c, d);
    849.  
    850.         }
    851.         else
    852.         {
    853.             printf("你不可以这样做！\n");
    854.         }
    855.     }
    856.     else if (map[a][b].id == blackchess[1] || map[a][b].id == redchess[1])
    857.     {
    858.  
    859.  
    860.         if (ma(a, b, c, d))
    861.         {
    862.             movechess(a, b, c, d);
    863.  
    864.  
    865.         }
    866.         else
    867.         {
    868.             printf("你不能这样做！\n");
    869.         }
    870.  
    871.     }
    872.     else if (map[a][b].id == blackchess[2] || map[a][b].id == redchess[2])
    873.     {
    874.         if (xiang(a, b, c, d))
    875.         {
    876.             movechess(a, b, c, d);
    877.  
    878.         }
    879.         else
    880.             printf("你不能这样做！\n");
    881.  
    882.     }
    883.     else if (map[a][b].id == blackchess[3])
    884.     {
    885.         if (shi(a, b, c, d))
    886.         {
    887.             movechess(a, b, c, d);
    888.  
    889.         }
    890.         else
    891.             printf("你不能这样做！");
    892.     }
    893.     else if (map[a][b].id == redchess[3])
    894.     {
    895.         if (shi(a, b, c, d))
    896.         {
    897.             movechess(a, b, c, d);
    898.  
    899.         }
    900.         else
    901.             printf("你不能这样做！");
    902.     }
    903. }
    904. int main()
    905. {
    906.     begining();
    907.     while (1)//当正确的时候
    908.     {
    909.         coord();//输出棋盘
    910.         win();
    911.         BeginBatchDraw();
    912.         /*这个函数用于开始批量绘图。执行后
    913.         任何绘图操作都将暂时不输出到绘图窗口上，直到执行 FlushBatchDraw 或 EndBatchDraw 才将之前的绘图输出。*/
    914.         //运行BeginBatchDraw后，所有的绘图都不再显示在屏幕上，而是在内存中进行
    915.         //封装的双缓存,避免闪屏
    916.         /*那如果我们能让打印的过程不显示出来，只显示打印完后的显示缓冲区不就行了吗*/
    917.         while (win() == 2)//平局状态,是不是还需要继续运行下去?
    918.         {
    919.             win();
    920.             putimage(0, 0, &img);
    921.             getbackground();//输出棋子
    922.             MouseControl();//鼠标更改数据
    923.             FlushBatchDraw();/*这个函数用于执行未完成的绘制任务。*/
    924.  
    925.         }
    926.  
    927.         putimage(0, 0, &img);
    928.         getbackground();//输出棋子
    929.         MouseControl();//鼠标更改数据
    930.         FlushBatchDraw();/*这个函数用于执行未完成的绘制任务。*/
    931.         if (win() == 0)
    932.         {
    933.             printf("红方胜！\n");
    934.         }
    935.         else if (win() == 1)
    936.         {
    937.             printf("黑方胜！\n");
    938.  
    939.         }
    940.     }
    941.     getchar();
    942.  
    943.     return 0;
    944. }

    总代码参考于:

    (1条消息) 基于c语言的象棋游戏_m0_59564114的博客-CSDN博客_c语言象棋游戏代码

  • 相关阅读:
    CSS的元素显示模式和CSS的背景
    Microsoft 10/11 命令行打开系统设置页（WUAP，!WIN32）
    AI网络爬虫：批量爬取AI导航网站Futurepedia数据
    安全开发实战(3)--存活探测与端口扫描
    Dubbo启动报错
    代理模式详解
    11. 盛最多水的容器
    孙宇晨式“溢价逻辑”：不局限眼前，为全人类的“星辰大海”大胆下注
    【文献阅读】Cascaded Partial Decoder for Fast and Accurate Salient Object Detection
    大厂面试sql手撕题目总结
  • 原文地址：https://blog.csdn.net/Lukegood/article/details/128096856