Diffstat (limited to 'noncore/games/kcheckers/rcheckers.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r-- | noncore/games/kcheckers/rcheckers.cpp | 476 |
1 files changed, 476 insertions, 0 deletions
diff --git a/noncore/games/kcheckers/rcheckers.cpp b/noncore/games/kcheckers/rcheckers.cpp new file mode 100644 index 0000000..a1c7afa --- a/dev/null +++ b/noncore/games/kcheckers/rcheckers.cpp | |||
@@ -0,0 +1,476 @@ | |||
1 | // | ||
2 | // Russian Checkers | ||
3 | |||
4 | |||
5 | #include "rcheckers.h" | ||
6 | |||
7 | |||
8 | /////////////////////////////////////////////////// | ||
9 | // | ||
10 | // User Functions | ||
11 | // | ||
12 | /////////////////////////////////////////////////// | ||
13 | |||
14 | |||
15 | bool RCheckers::go1(int from,int field) | ||
16 | { | ||
17 | to=field; | ||
18 | |||
19 | if(checkCapture1()) | ||
20 | { | ||
21 | bool capture=false; | ||
22 | switch(board[from]) | ||
23 | { | ||
24 | case MAN1: | ||
25 | if(manCapture1(from,UL,capture)) return true; | ||
26 | if(manCapture1(from,UR,capture)) return true; | ||
27 | if(manCapture1(from,DL,capture)) return true; | ||
28 | if(manCapture1(from,DR,capture)) return true; | ||
29 | return false; | ||
30 | case KING1: | ||
31 | if(kingCapture1(from,UL,capture)) return true; | ||
32 | if(kingCapture1(from,UR,capture)) return true; | ||
33 | if(kingCapture1(from,DL,capture)) return true; | ||
34 | if(kingCapture1(from,DR,capture)) return true; | ||
35 | return false; | ||
36 | } | ||
37 | } | ||
38 | else | ||
39 | { | ||
40 | switch(board[from]) | ||
41 | { | ||
42 | case MAN1: | ||
43 | if((to==(from-6))||(to==(from-5))) | ||
44 | { | ||
45 | board[from]=FREE; | ||
46 | if(to<10) board[to]=KING1; | ||
47 | else board[to]=MAN1; | ||
48 | return true; | ||
49 | } | ||
50 | return false; | ||
51 | case KING1: | ||
52 | for(int i=from-6;;i-=6) | ||
53 | { | ||
54 | if(i==to) | ||
55 | { | ||
56 | board[from]=FREE; | ||
57 | board[to]=KING1; | ||
58 | return true; | ||
59 | } | ||
60 | else if(board[i]==FREE) continue; | ||
61 | else break; | ||
62 | } | ||
63 | for(int i=from-5;;i-=5) | ||
64 | { | ||
65 | if(i==to) | ||
66 | { | ||
67 | board[from]=FREE; | ||
68 | board[to]=KING1; | ||
69 | return true; | ||
70 | } | ||
71 | else if(board[i]==FREE) continue; | ||
72 | else break; | ||
73 | } | ||
74 | for(int i=from+5;;i+=5) | ||
75 | { | ||
76 | if(i==to) | ||
77 | { | ||
78 | board[from]=FREE; | ||
79 | board[to]=KING1; | ||
80 | return true; | ||
81 | } | ||
82 | else if(board[i]==FREE) continue; | ||
83 | else break; | ||
84 | } | ||
85 | for(int i=from+6;;i+=6) | ||
86 | { | ||
87 | if(i==to) | ||
88 | { | ||
89 | board[from]=FREE; | ||
90 | board[to]=KING1; | ||
91 | return true; | ||
92 | } | ||
93 | else if(board[i]==FREE) continue; | ||
94 | else break; | ||
95 | } | ||
96 | return false; | ||
97 | } | ||
98 | } | ||
99 | return false; | ||
100 | } | ||
101 | |||
102 | |||
103 | bool RCheckers::checkCapture1() | ||
104 | { | ||
105 | for(int i=6;i<48;i++) | ||
106 | { | ||
107 | switch(board[i]) | ||
108 | { | ||
109 | case MAN1: | ||
110 | if(board[i-6]==MAN2 || board[i-6]==KING2) | ||
111 | if(board[i-12]==FREE) return true; | ||
112 | if(board[i-5]==MAN2 || board[i-5]==KING2) | ||
113 | if(board[i-10]==FREE) return true; | ||
114 | if(board[i+5]==MAN2 || board[i+5]==KING2) | ||
115 | if(board[i+10]==FREE) return true; | ||
116 | if(board[i+6]==MAN2 || board[i+6]==KING2) | ||
117 | if(board[i+12]==FREE) return true; | ||
118 | break; | ||
119 | case KING1: | ||
120 | int k; | ||
121 | for(k=i-6;board[k]==FREE;k-=6); | ||
122 | if(board[k]==MAN2 || board[k]==KING2) | ||
123 | if(board[k-6]==FREE) return true; | ||
124 | |||
125 | for(k=i-5;board[k]==FREE;k-=5); | ||
126 | if(board[k]==MAN2 || board[k]==KING2) | ||
127 | if(board[k-5]==FREE) return true; | ||
128 | |||
129 | for(k=i+5;board[k]==FREE;k+=5); | ||
130 | if(board[k]==MAN2 || board[k]==KING2) | ||
131 | if(board[k+5]==FREE) return true; | ||
132 | |||
133 | for(k=i+6;board[k]==FREE;k+=6); | ||
134 | if(board[k]==MAN2 || board[k]==KING2) | ||
135 | if(board[k+6]==FREE) return true; | ||
136 | } | ||
137 | } | ||
138 | return false; | ||
139 | } | ||
140 | |||
141 | |||
142 | // Return TRUE if a course of the user true | ||
143 | // Return FALSE if a course of the user incorrect | ||
144 | |||
145 | bool RCheckers::manCapture1(int from,int direction,bool &capture) | ||
146 | { | ||
147 | int i=from+direction; | ||
148 | if(board[i]==MAN2 || board[i]==KING2) | ||
149 | { | ||
150 | int k=i+direction; | ||
151 | if(board[k]==FREE) | ||
152 | { | ||
153 | bool next=false; | ||
154 | int save=board[i]; | ||
155 | board[from]=FREE; | ||
156 | board[i]=NONE; | ||
157 | |||
158 | if(k<10) | ||
159 | { | ||
160 | board[k]=KING1; | ||
161 | if(kingCapture1(k,direction+11,next)) {board[i]=FREE;return true;} | ||
162 | } | ||
163 | else | ||
164 | { | ||
165 | board[k]=MAN1; | ||
166 | if(direction==UL || direction==DR) | ||
167 | { | ||
168 | if(manCapture1(k,UR,next)) {board[i]=FREE;return true;} | ||
169 | if(manCapture1(k,DL,next)) {board[i]=FREE;return true;} | ||
170 | } | ||
171 | else | ||
172 | { | ||
173 | if(manCapture1(k,UL,next)) {board[i]=FREE;return true;} | ||
174 | if(manCapture1(k,DR,next)) {board[i]=FREE;return true;} | ||
175 | } | ||
176 | if(manCapture1(k,direction,next)) {board[i]=FREE;return true;} | ||
177 | } | ||
178 | |||
179 | if((!next) && k==to) {board[i]=FREE;return true;} | ||
180 | |||
181 | board[k]=FREE; | ||
182 | board[i]=save; | ||
183 | board[from]=MAN1; | ||
184 | capture=true; | ||
185 | } | ||
186 | } | ||
187 | return false; | ||
188 | } | ||
189 | |||
190 | |||
191 | bool RCheckers::kingCapture1(int from,int direction,bool &capture) | ||
192 | { | ||
193 | int i; | ||
194 | for(i=from+direction;board[i]==FREE;i+=direction); | ||
195 | |||
196 | if(board[i]==MAN2 || board[i]==KING2) | ||
197 | { | ||
198 | int k=i+direction; | ||
199 | if(board[k]==FREE) | ||
200 | { | ||
201 | bool next=false; | ||
202 | int save=board[i]; | ||
203 | board[from]=FREE; | ||
204 | board[i]=NONE; | ||
205 | |||
206 | for(;board[k]==FREE;k+=direction) | ||
207 | { | ||
208 | board[k]=KING1; | ||
209 | if(direction==UL || direction==DR) | ||
210 | { | ||
211 | if(kingCapture1(k,UR,next)) {board[i]=FREE;return true;} | ||
212 | if(kingCapture1(k,DL,next)) {board[i]=FREE;return true;} | ||
213 | } | ||
214 | else | ||
215 | { | ||
216 | if(kingCapture1(k,UL,next)) {board[i]=FREE;return true;} | ||
217 | if(kingCapture1(k,DR,next)) {board[i]=FREE;return true;} | ||
218 | } | ||
219 | board[k]=FREE; | ||
220 | } | ||
221 | |||
222 | board[k-=direction]=KING1; | ||
223 | if(kingCapture1(k,direction,next)) {board[i]=FREE;return true;} | ||
224 | board[k]=FREE; | ||
225 | |||
226 | if(!next) | ||
227 | for(;k!=i;k-=direction) | ||
228 | if(k==to) {board[i]=FREE;board[k]=KING1;return true;} | ||
229 | |||
230 | board[i]=save; | ||
231 | board[from]=KING1; | ||
232 | capture=true; | ||
233 | } | ||
234 | } | ||
235 | return false; | ||
236 | } | ||
237 | |||
238 | |||
239 | //////////////////////////////////////////////////// | ||
240 | // | ||
241 | // Computer Functions | ||
242 | // | ||
243 | //////////////////////////////////////////////////// | ||
244 | |||
245 | |||
246 | void RCheckers::kingMove2(int from,int &resMax) | ||
247 | { | ||
248 | board[from]=FREE; | ||
249 | for(int i=from-6;board[i]==FREE;i-=6) | ||
250 | { | ||
251 | board[i]=KING2; | ||
252 | turn(resMax); | ||
253 | board[i]=FREE; | ||
254 | } | ||
255 | for(int i=from-5;board[i]==FREE;i-=5) | ||
256 | { | ||
257 | board[i]=KING2; | ||
258 | turn(resMax); | ||
259 | board[i]=FREE; | ||
260 | } | ||
261 | for(int i=from+5;board[i]==FREE;i+=5) | ||
262 | { | ||
263 | board[i]=KING2; | ||
264 | turn(resMax); | ||
265 | board[i]=FREE; | ||
266 | } | ||
267 | for(int i=from+6;board[i]==FREE;i+=6) | ||
268 | { | ||
269 | board[i]=KING2; | ||
270 | turn(resMax); | ||
271 | board[i]=FREE; | ||
272 | } | ||
273 | board[from]=KING2; | ||
274 | } | ||
275 | |||
276 | |||
277 | bool RCheckers::checkCapture2() | ||
278 | { | ||
279 | for(int i=6;i<48;i++) | ||
280 | { | ||
281 | switch(board[i]) | ||
282 | { | ||
283 | case MAN2: | ||
284 | if(board[i-6]==MAN1 || board[i-6]==KING1) | ||
285 | if(board[i-12]==FREE) return true; | ||
286 | if(board[i-5]==MAN1 || board[i-5]==KING1) | ||
287 | if(board[i-10]==FREE) return true; | ||
288 | if(board[i+5]==MAN1 || board[i+5]==KING1) | ||
289 | if(board[i+10]==FREE) return true; | ||
290 | if(board[i+6]==MAN1 || board[i+6]==KING1) | ||
291 | if(board[i+12]==FREE) return true; | ||
292 | break; | ||
293 | case KING2: | ||
294 | int k; | ||
295 | for(k=i-6;board[k]==FREE;k-=6); | ||
296 | if(board[k]==MAN1 || board[k]==KING1) | ||
297 | if(board[k-6]==FREE) return true; | ||
298 | |||
299 | for(k=i-5;board[k]==FREE;k-=5); | ||
300 | if(board[k]==MAN1 || board[k]==KING1) | ||
301 | if(board[k-5]==FREE) return true; | ||
302 | |||
303 | for(k=i+5;board[k]==FREE;k+=5); | ||
304 | if(board[k]==MAN1 || board[k]==KING1) | ||
305 | if(board[k+5]==FREE) return true; | ||
306 | |||
307 | for(k=i+6;board[k]==FREE;k+=6); | ||
308 | if(board[k]==MAN1 || board[k]==KING1) | ||
309 | if(board[k+6]==FREE) return true; | ||
310 | } | ||
311 | } | ||
312 | return false; | ||
313 | } | ||
314 | |||
315 | |||
316 | // Return TRUE if it is possible to capture | ||
317 | // Return FALSE if it is impossible to capture | ||
318 | |||
319 | bool RCheckers::manCapture2(int from,int &resMax) | ||
320 | { | ||
321 | bool capture=false; | ||
322 | |||
323 | int i=from-6; | ||
324 | if(board[i]==MAN1 || board[i]==KING1) | ||
325 | { | ||
326 | int k=from-12; | ||
327 | if(board[k]==FREE) | ||
328 | { | ||
329 | int save=board[i]; | ||
330 | board[from]=FREE; | ||
331 | board[i]=NONE; | ||
332 | board[k]=MAN2; | ||
333 | resMax--; | ||
334 | if(!manCapture2(k,resMax)) turn(resMax,true); | ||
335 | resMax++; | ||
336 | board[k]=FREE; | ||
337 | board[i]=save; | ||
338 | board[from]=MAN2; | ||
339 | capture=true; | ||
340 | } | ||
341 | } | ||
342 | |||
343 | i=from-5; | ||
344 | if(board[i]==MAN1 || board[i]==KING1) | ||
345 | { | ||
346 | int k=from-10; | ||
347 | if(board[k]==FREE) | ||
348 | { | ||
349 | int save=board[i]; | ||
350 | board[from]=FREE; | ||
351 | board[i]=NONE; | ||
352 | board[k]=MAN2; | ||
353 | resMax--; | ||
354 | if(!manCapture2(k,resMax)) turn(resMax,true); | ||
355 | resMax++; | ||
356 | board[k]=FREE; | ||
357 | board[i]=save; | ||
358 | board[from]=MAN2; | ||
359 | capture=true; | ||
360 | } | ||
361 | } | ||
362 | |||
363 | i=from+5; | ||
364 | if(board[i]==MAN1 || board[i]==KING1) | ||
365 | { | ||
366 | int k=from+10; | ||
367 | if(board[k]==FREE) | ||
368 | { | ||
369 | int save=board[i]; | ||
370 | board[from]=FREE; | ||
371 | board[i]=NONE; | ||
372 | resMax--; | ||
373 | if(from>32) | ||
374 | { | ||
375 | board[k]=KING2; | ||
376 | if(!kingCapture2(k,UL,resMax)) turn(resMax,true); | ||
377 | } | ||
378 | else | ||
379 | { | ||
380 | board[k]=MAN2; | ||
381 | if(!manCapture2(k,resMax)) turn(resMax,true); | ||
382 | } | ||
383 | resMax++; | ||
384 | board[k]=FREE; | ||
385 | board[i]=save; | ||
386 | board[from]=MAN2; | ||
387 | capture=true; | ||
388 | } | ||
389 | } | ||
390 | |||
391 | i=from+6; | ||
392 | if(board[i]==MAN1 || board[i]==KING1) | ||
393 | { | ||
394 | int k=from+12; | ||
395 | if(board[k]==FREE) | ||
396 | { | ||
397 | int save=board[i]; | ||
398 | board[from]=FREE; | ||
399 | board[i]=NONE; | ||
400 | resMax--; | ||
401 | if(from>32) | ||
402 | { | ||
403 | board[k]=KING2; | ||
404 | if(!kingCapture2(k,UR,resMax)) turn(resMax,true); | ||
405 | } | ||
406 | else | ||
407 | { | ||
408 | board[k]=MAN2; | ||
409 | if(!manCapture2(k,resMax)) turn(resMax,true); | ||
410 | } | ||
411 | resMax++; | ||
412 | board[k]=FREE; | ||
413 | board[i]=save; | ||
414 | board[from]=MAN2; | ||
415 | capture=true; | ||
416 | } | ||
417 | } | ||
418 | |||
419 | if(capture) return true; | ||
420 | return false; | ||
421 | } | ||
422 | |||
423 | |||
424 | bool RCheckers::kingCapture2(int from,int direction,int &resMax) | ||
425 | { | ||
426 | int i; | ||
427 | for(i=from+direction;board[i]==FREE;i+=direction); | ||
428 | |||
429 | if(board[i]==MAN1 || board[i]==KING1) | ||
430 | { | ||
431 | int k=i+direction; | ||
432 | if(board[k]==FREE) | ||
433 | { | ||
434 | bool capture=false; | ||
435 | int save=board[i]; | ||
436 | board[from]=FREE; | ||
437 | board[i]=NONE; | ||
438 | resMax--; | ||
439 | |||
440 | for(;board[k]==FREE;k+=direction) | ||
441 | { | ||
442 | board[k]=KING2; | ||
443 | if(direction==UL || direction==DR) | ||
444 | { | ||
445 | if(kingCapture2(k,UR,resMax)) capture=true; | ||
446 | if(kingCapture2(k,DL,resMax)) capture=true; | ||
447 | } | ||
448 | else | ||
449 | { | ||
450 | if(kingCapture2(k,UL,resMax)) capture=true; | ||
451 | if(kingCapture2(k,DR,resMax)) capture=true; | ||
452 | } | ||
453 | board[k]=FREE; | ||
454 | } | ||
455 | |||
456 | board[k-=direction]=KING2; | ||
457 | if(kingCapture2(k,direction,resMax)) capture=true; | ||
458 | board[k]=FREE; | ||
459 | |||
460 | if(!capture) | ||
461 | for(;k!=i;k-=direction) | ||
462 | { | ||
463 | board[k]=KING2; | ||
464 | turn(resMax,true); | ||
465 | board[k]=FREE; | ||
466 | } | ||
467 | |||
468 | resMax++; | ||
469 | board[i]=save; | ||
470 | board[from]=KING2; | ||
471 | return true; | ||
472 | } | ||
473 | } | ||
474 | return false; | ||
475 | } | ||
476 | |||