[已解决]谁来帮帮我呀？？？ 没有棋规，棋子可以随意走。。

zmrghy

用了4天半的时间，终于可以走棋子子。。
谁来帮帮我呀？？？ 没有棋规，棋子可以随意走。。
谁会写棋规呀，求分享思路。。。。




ChineseChess.rar (1.91 KB, 下载次数: 2)

2021-12-15 23:19 上传

点击文件名下载附件

1. 
   
2. 
   
3. #include<stdio.h>
   
4. #include<easyx.h>
   
5. #include<math.h>
   
6. 
   
7. #define ROW 10
   
8. #define COL 9
   
9. #define INTERVAL 35                //边距
   
10. #define GRID_SIZE 70        //格子宽度
    
11. 
    
12. enum Pieces                //棋子
    
13. {
    
14.         NONE = -1,
    
15.         俥,马,相,仕,帥,炮,兵,        //红子
    
16.         車,馬,象,士,将,砲,卒,        //绿子
    
17.         BEGIN,END,
    
18. };
    
19. //给id赋值
    
20. enum Pieces greenChess[] = {車,馬,象,士,将,砲,卒};
    
21. enum Pieces redChess[] = {俥,马,相,仕,帥,炮,兵};
    
22. //绘制时转化成字符串
    
23. const char* ChessName[]= {"俥","马","相","仕","帥","炮","兵","車","馬","象","士","将","砲","卒"};
    
24. //每一个棋子的属性
    
25. struct Chess
    
26. {
    
27.         enum Pieces id;                //棋子名称
    
28.         DWORD type;                        //棋子类型，红？绿？
    
29.         short x;
    
30.         short y;
    
31.         bool  isRiver;                        //是否过河
    
32. };
    
33. //游戏地图
    
34. struct Chess map[ROW][COL];
    
35. 
    
36. struct State
    
37. {
    
38.         int begr;
    
39.         int begc;
    
40.         int endr;
    
41.         int endc;
    
42.         int state;
    
43. }state = {-1,-1,-1,-1, BEGIN};
    
44. IMAGE img_board;  //声明棋盘图片变量
    
45. //初始化数据
    
46. void init()
    
47. {
    
48.         //遍历地图
    
49.         for(size_t i=0; i<ROW; i++)
    
50.         {
    
51.                 size_t temp = 0;
    
52.                 for(size_t k=0; k<COL; k++)
    
53.                 {
    
54.                         map[i][k].id = NONE;
    
55.                         if(i<=4)                //绿棋子
    
56.                         {
    
57.                                 map[i][k].type = GREEN;
    
58.                                 if(i == 0)                //放置第一行的棋子
    
59.                                 {
    
60.                                         if(k<=4)
    
61.                                         {
    
62.                                                 temp=k;
    
63.                                         }
    
64.                                         else
    
65.                                         {
    
66.                                                 temp = 4-(k-4);
    
67.                                         }
    
68.                                         map[i][k].id=greenChess[temp];
    
69.                                 }
    
70.                                 if(i==2 && (k==1 || k==7))
    
71.                                 {
    
72.                                         map[i][k].id=greenChess[5];
    
73.                                 }
    
74.                                 if(i==3 && (k%2) ==0)
    
75.                                 {
    
76.                                         map[i][k].id=greenChess[6];
    
77.                                 }
    
78.                         }
    
79.                        
    
80.                         else                        //红棋子
    
81.                         {
    
82.                                 map[i][k].type = RED;
    
83.                                 if(i == 9)                //放置第一行的棋子
    
84.                                 {
    
85.                                         if(k<=4)
    
86.                                         {
    
87.                                                 temp=k;
    
88.                                         }
    
89.                                         else
    
90.                                         {
    
91.                                                 temp = 4-(k-4);
    
92.                                         }
    
93.                                         map[i][k].id=redChess[temp];
    
94.                                 }
    
95.                                 if(i==7 && (k==1 || k==7))
    
96.                                 {
    
97.                                         map[i][k].id=redChess[5];
    
98.                                 }
    
99.                                 if(i==6 && (k%2) ==0)
    
100.                                 {
     
101.                                         map[i][k].id=redChess[6];
     
102.                                 }
     
103.                         }
     
104.                         map[i][k].isRiver = false;
     
105.                         map[i][k].x = k*GRID_SIZE+INTERVAL;
     
106.                         map[i][k].y = i*GRID_SIZE+INTERVAL;
     
107.                 }
     
108.         }
     
109. }
     
110. //绘制
     
111. void draw()
     
112. {
     
113.         setlinestyle(PS_SOLID,3);
     
114.         //设置文字样式
     
115.         settextstyle(36,0,"楷体");
     
116.         for(size_t i=0; i<ROW; i++)
     
117.         {
     
118.                 for(size_t k=0; k<COL; k++)
     
119.                 {
     
120.                         if(map[i][k].id == NONE)
     
121.                                 continue;
     
122.                         settextcolor(map[i][k].type);
     
123.                         setlinecolor(map[i][k].type);
     
124.                         //绘制棋子
     
125.                         fillcircle(map[i][k].x, map[i][k].y, 30);
     
126.                         outtextxy(map[i][k].x-18, map[i][k].y-18, ChessName[map[i][k].id]);
     
127.                 }
     
128.         }
     
129. }
     
130. //判断是否点击在棋子上
     
131. bool if_in_pieces(DWORD cir_x, DWORD cir_y, DWORD cir_r, DWORD dot_x,DWORD dot_y)
     
132. {
     
133.         DWORD a=0, b=0;
     
134.         double c=0.0;
     
135.         a=(cir_x > dot_x)?  cir_x-dot_x : dot_x-cir_x;
     
136.         b=(cir_y > dot_y)?  cir_y-dot_y : dot_y-cir_y;
     
137.         c = sqrt((a*a+b*b)*1.0);
     
138.         if(cir_r*1.0 > c)
     
139.                 return 1; //返回1，表示点在圆内
     
140.         else
     
141.                 return 0; //返回0，表示点在圆内
     
142. }
     
143. //移动棋子
     
144. void chessMove()
     
145. {
     
146.         map[state.endr][state.endc].id = map[state.begr][state.begc].id;
     
147.         map[state.endr][state.endc].type = map[state.begr][state.begc].type;
     
148.         map[state.begr][state.begc].id = NONE;
     
149.         putimage(0,0,&img_board);
     
150.                 setlinestyle(PS_SOLID,3);
     
151.         //设置文字样式
     
152.         settextstyle(36,0,"楷体");
     
153.         for(size_t i=0; i<ROW; i++)
     
154.         {
     
155.                 for(size_t k=0; k<COL; k++)
     
156.                 {
     
157.                         if(map[i][k].id == NONE)
     
158.                                 continue;
     
159.                         settextcolor(map[i][k].type);
     
160.                         setlinecolor(map[i][k].type);
     
161.                         //绘制棋子
     
162.                         fillcircle(map[i][k].x, map[i][k].y, 30);
     
163.                         outtextxy(map[i][k].x-18, map[i][k].y-18, ChessName[map[i][k].id]);
     
164.                 }
     
165.         }
     
166. }
     
167. //鼠标操作
     
168. void mouseEvent()
     
169. {
     
170.         ExMessage msg;        //定义消息结构体变量
     
171.         if(peekmessage(&msg,EM_MOUSE))
     
172.         {
     
173.                 if(msg.message == WM_LBUTTONDOWN)         //鼠标左键按下
     
174.                 {
     
175.                         //通过鼠标点击坐标得出棋盘位置
     
176.                         for(size_t i=0; i<ROW; i++)
     
177.                         {
     
178.                                 for(size_t j=0; j<COL; j++)
     
179.                                 {
     
180.                                         if(if_in_pieces(msg.x, msg.y, 30, j*GRID_SIZE+INTERVAL, i*GRID_SIZE+INTERVAL))
     
181.                                         {
     
182.                                                 if(map[i][j].id !=NONE || state.state==END)
     
183.                                                 {
     
184.                                                         if(state.state == BEGIN)
     
185.                                                         {
     
186.                                                                 state.begr = i;
     
187.                                                                 state.begc = j;
     
188.                                                                 state.state = END;
     
189.                                                                 setlinecolor(BLUE);
     
190.                                                                 rectangle(j*GRID_SIZE,  (i+1)*GRID_SIZE, (j+1)*GRID_SIZE,  i*GRID_SIZE);
     
191.                                                         return ;
     
192.                                                         }
     
193.                                                         else if(state.state == END)
     
194.                                                         {
     
195.                                                                 state.endr = i;
     
196.                                                                 state.endc = j;
     
197.                                                                 state.state = BEGIN;
     
198.                                                                 if(!(state.endr == state.begr && state.endc ==state.begc))
     
199.                                                                 chessMove();
     
200.                                                                 else
     
201.                                                                 {
     
202.                                                                         putimage(0,0,&img_board);
     
203.                                                                         setlinestyle(PS_SOLID,3);
     
204.                                                                         //设置文字样式
     
205.                                                                         settextstyle(36,0,"楷体");
     
206.                                                                         for(size_t i=0; i<ROW; i++)
     
207.                                                                         {
     
208.                                                                                 for(size_t k=0; k<COL; k++)
     
209.                                                                                 {
     
210.                                                                                         if(map[i][k].id == NONE)
     
211.                                                                                                 continue;
     
212.                                                                                         settextcolor(map[i][k].type);
     
213.                                                                                         setlinecolor(map[i][k].type);
     
214.                                                                                         //绘制棋子
     
215.                                                                                         fillcircle(map[i][k].x, map[i][k].y, 30);
     
216.                                                                                         outtextxy(map[i][k].x-18, map[i][k].y-18, ChessName[map[i][k].id]);
     
217.                                                                                 }
     
218.                                                                         }
     
219. 
     
220.                                                                 }
     
221.                                                                 return ;
     
222.                                                         }
     
223.                                                 }
     
224.                                                 return ;
     
225.                                         }
     
226.                                 }
     
227.                         }
     
228.                 }
     
229.         }
     
230. }
     
231. void main()
     
232. {
     
233.         //创建图形窗口
     
234.         //initgraph(632,700,EW_OWCONSOLE)
     
235.         initgraph(632,700);
     
236.         //设置背景模式
     
237.         setbkmode(TRANSPARENT);
     
238.         //贴棋盘
     
239.         loadimage(&img_board,"./res/ChessBoard.png");
     
240.         putimage(0,0,&img_board);
     
241.         init();
     
242.         draw();
     
243.         while(1)
     
244.                 mouseEvent();
     
245.         getchar();
     
246. }
     

复制代码

最佳答案

月排行榜 / 总排行榜

freehawkzk

2021-12-16 08:46:25

只是要限制棋子可以下的位置的话，你可以在选定棋子之后根据棋子的规则，限制一下。比如，马只能按照日字的方式走，由于当前位置是知道的，那么在棋盘上满足日字规则的位置也是确定的，再看下哪些位置有棋子，日字的限制位置有没有棋子等，就可以算出这个马的可选目标位置了。

跳转到最佳答案楼层

thzzl

以前看到过一本叫《C/C++中国象棋程序入门与提高》的书，好像介绍了关于象棋的算法，但由于不是个人兴趣，就只看了看目录。

freehawkzk

只是要限制棋子可以下的位置的话，你可以在选定棋子之后根据棋子的规则，限制一下。比如，马只能按照日字的方式走，由于当前位置是知道的，那么在棋盘上满足日字规则的位置也是确定的，再看下哪些位置有棋子，日字的限制位置有没有棋子等，就可以算出这个马的可选目标位置了。