+
1
+
2
+
3
+
4
+
5
+
6
+
7
+
8
+
9
+
10
+
11
+
12
+
13
+
14
+
15
+
16
+
17
+
18
+
19
+
20
+
21
+
22
+
23
+
24
+
25
+
26
+
27
+
28
+
29
+
30 #include "rules.h"
+
31 #include "chess.h"
+
32 #include <string.h>
+
33 #include <stdlib.h>
+
34 #include <sys/time.h>
+
35
+
36 static GameState gamestate_copy_sim(GameState *gamestate) {
+
37 GameState simulation = *gamestate;
+
38 if (simulation.lastmove) {
+
39 MoveList *lastmovecopy = malloc(
sizeof(MoveList));
+
40 *lastmovecopy = *(simulation.lastmove);
+
41 simulation.movelist = simulation.lastmove = lastmovecopy;
+
42 }
+
43
+
44 return simulation;
+
45 }
+
46
+
47 void gamestate_init(GameState *gamestate) {
+
48 memset(gamestate,
0,
sizeof(GameState));
+
49
+
50 Board initboard = {
+
51 {
WROOK,
WKNIGHT,
WBISHOP,
WQUEEN,
WKING,
WBISHOP,
WKNIGHT,
WROOK},
+
52 {
WPAWN,
WPAWN,
WPAWN,
WPAWN,
WPAWN,
WPAWN,
WPAWN,
WPAWN},
+
53 {
0,
0,
0,
0,
0,
0,
0,
0},
+
54 {
0,
0,
0,
0,
0,
0,
0,
0},
+
55 {
0,
0,
0,
0,
0,
0,
0,
0},
+
56 {
0,
0,
0,
0,
0,
0,
0,
0},
+
57 {
BPAWN,
BPAWN,
BPAWN,
BPAWN,
BPAWN,
BPAWN,
BPAWN,
BPAWN},
+
58 {
BROOK,
BKNIGHT,
BBISHOP,
BQUEEN,
BKING,
BBISHOP,
BKNIGHT,
BROOK}
+
59 };
+
60 memcpy(gamestate->board, initboard,
sizeof(Board));
+
61 }
+
62
+
63 void gamestate_cleanup(GameState *gamestate) {
+
64 MoveList *elem;
+
65 elem = gamestate->movelist;
+
66 while (elem) {
+
67 MoveList *cur = elem;
+
68 elem = elem->next;
+
69 free(cur);
+
70 };
+
71 }
+
72
+
73
+
74 static void format_move(GameState *gamestate, Move *move) {
+
75 char *string = move->string;
+
76
+
77
+
78 memset(string,
0,
8);
+
79
+
80
+
81 if ((move->piece&
PIECE_MASK) ==
KING &&
+
82 abs(move->tofile-move->fromfile) ==
2) {
+
83 if (move->tofile==fileidx(
'c')) {
+
84 memcpy(string,
"O-O-O",
5);
+
85 }
else {
+
86 memcpy(string,
"O-O",
3);
+
87 }
+
88 }
+
89
+
90
+
91 string[
0] = getpiecechr(move->piece);
+
92 int idx = string[
0] ?
1 :
0;
+
93
+
94
+
95 uint8_t piece = move->piece &
PIECE_MASK;
+
96 if (piece ==
PAWN) {
+
97 if (move->capture) {
+
98 string[idx++] = filechr(move->fromfile);
+
99 }
+
100 }
else if (piece !=
KING) {
+
101 Move threats[
16];
+
102 uint8_t threatcount;
+
103 get_real_threats(gamestate, move->torow, move->tofile,
+
104 move->piece&
COLOR_MASK, threats, &threatcount);
+
105 if (threatcount >
1) {
+
106 int ambrows =
0, ambfiles =
0;
+
107 for (
uint8_t i =
0 ; i < threatcount ; i++) {
+
108 if (threats[i].fromrow == move->fromrow) {
+
109 ambrows++;
+
110 }
+
111 if (threats[i].fromfile == move->fromfile) {
+
112 ambfiles++;
+
113 }
+
114 }
+
115
+
116 if (ambrows >
1) {
+
117 string[idx++] = filechr(move->fromfile);
+
118 }
+
119
+
120 if (ambfiles >
1) {
+
121 string[idx++] = filechr(move->fromrow);
+
122 }
+
123 }
+
124 }
+
125
+
126
+
127 if (move->capture) {
+
128 string[idx++] =
'x';
+
129 }
+
130
+
131
+
132 string[idx++] = filechr(move->tofile);
+
133 string[idx++] = rowchr(move->torow);
+
134
+
135
+
136 if (move->promotion) {
+
137 string[idx++] =
'=';
+
138 string[idx++] = getpiecechr(move->promotion);
+
139 }
+
140
+
141
+
142 if (move->check) {
+
143
+
144 string[idx++] = gamestate->checkmate?
'#':
'+';
+
145 }
+
146 }
+
147
+
148 static void addmove(GameState* gamestate, Move *move) {
+
149 MoveList *elem = malloc(
sizeof(MoveList));
+
150 elem->next =
NULL;
+
151 elem->move = *move;
+
152
+
153 struct timeval curtimestamp;
+
154 gettimeofday(&curtimestamp,
NULL);
+
155 elem->move.timestamp.tv_sec = curtimestamp.tv_sec;
+
156 elem->move.timestamp.tv_usec = curtimestamp.tv_usec;
+
157
+
158 if (gamestate->lastmove) {
+
159 struct movetimeval *lasttstamp = &(gamestate->lastmove->move.timestamp);
+
160 uint64_t sec = curtimestamp.tv_sec - lasttstamp->tv_sec;
+
161 suseconds_t micros;
+
162 if (curtimestamp.tv_usec < lasttstamp->tv_usec) {
+
163 micros = 1e6L-(lasttstamp->tv_usec - curtimestamp.tv_usec);
+
164 sec--;
+
165 }
else {
+
166 micros = curtimestamp.tv_usec - lasttstamp->tv_usec;
+
167 }
+
168
+
169 elem->move.movetime.tv_sec = sec;
+
170 elem->move.movetime.tv_usec = micros;
+
171
+
172 gamestate->lastmove->next = elem;
+
173 gamestate->lastmove = elem;
+
174 }
else {
+
175 elem->move.movetime.tv_usec =
0;
+
176 elem->move.movetime.tv_sec =
0;
+
177 gamestate->movelist = gamestate->lastmove = elem;
+
178 }
+
179 }
+
180
+
181 char getpiecechr(
uint8_t piece) {
+
182 switch (piece &
PIECE_MASK) {
+
183 case ROOK:
return 'R';
+
184 case KNIGHT:
return 'N';
+
185 case BISHOP:
return 'B';
+
186 case QUEEN:
return 'Q';
+
187 case KING:
return 'K';
+
188 default:
return '\0';
+
189 }
+
190 }
+
191
+
192 uint8_t getpiece(
char c) {
+
193 switch (c) {
+
194 case 'R':
return ROOK;
+
195 case 'N':
return KNIGHT;
+
196 case 'B':
return BISHOP;
+
197 case 'Q':
return QUEEN;
+
198 case 'K':
return KING;
+
199 default:
return 0;
+
200 }
+
201 }
+
202
+
203 static void apply_move_impl(GameState *gamestate, Move *move, _Bool simulate) {
+
204 uint8_t piece = move->piece &
PIECE_MASK;
+
205 uint8_t color = move->piece &
COLOR_MASK;
+
206
+
207
+
208 if (move->capture && piece ==
PAWN &&
+
209 mdst(gamestate->board, move) ==
0) {
+
210 gamestate->board[move->fromrow][move->tofile] =
0;
+
211 }
+
212
+
213
+
214 for (
uint8_t file =
0 ; file <
8 ; file++) {
+
215 gamestate->board[
3][file] &= ~
ENPASSANT_THREAT;
+
216 gamestate->board[
4][file] &= ~
ENPASSANT_THREAT;
+
217 }
+
218
+
219
+
220 if (piece ==
PAWN && (
+
221 (move->fromrow ==
1 && move->torow ==
3) ||
+
222 (move->fromrow ==
6 && move->torow ==
4))) {
+
223 move->piece |=
ENPASSANT_THREAT;
+
224 }
+
225
+
226
+
227 msrc(gamestate->board, move) =
0;
+
228 if (move->promotion) {
+
229 mdst(gamestate->board, move) = move->promotion;
+
230 }
else {
+
231 mdst(gamestate->board, move) = move->piece;
+
232 }
+
233
+
234
+
235 if (piece ==
KING && move->fromfile == fileidx(
'e')) {
+
236
+
237 if (move->tofile == fileidx(
'g')) {
+
238 gamestate->board[move->torow][fileidx(
'h')] =
0;
+
239 gamestate->board[move->torow][fileidx(
'f')] = color|
ROOK;
+
240 }
else if (move->tofile == fileidx(
'c')) {
+
241 gamestate->board[move->torow][fileidx(
'a')] =
0;
+
242 gamestate->board[move->torow][fileidx(
'd')] = color|
ROOK;
+
243 }
+
244 }
+
245
+
246 if (!simulate) {
+
247 if (!move->string[
0]) {
+
248 format_move(gamestate, move);
+
249 }
+
250 }
+
251
+
252 addmove(gamestate, move);
+
253 }
+
254
+
255 void apply_move(GameState *gamestate, Move *move) {
+
256 apply_move_impl(gamestate, move,
0);
+
257 }
+
258
+
259 static int validate_move_rules(GameState *gamestate, Move *move) {
+
260
+
261 if (!chkidx(move)) {
+
262 return INVALID_POSITION;
+
263 }
+
264
+
265
+
266 if (move->fromfile == move->tofile && move->fromrow == move->torow) {
+
267 return INVALID_MOVE_SYNTAX;
+
268 }
+
269
+
270
+
271 if ((msrc(gamestate->board, move)&(
PIECE_MASK|
COLOR_MASK))
+
272 != (move->piece&(
PIECE_MASK|
COLOR_MASK))) {
+
273 return INVALID_POSITION;
+
274 }
+
275
+
276
+
277 if ((mdst(gamestate->board, move) &
COLOR_MASK)
+
278 == (move->piece &
COLOR_MASK)) {
+
279 return RULES_VIOLATED;
+
280 }
+
281
+
282
+
283 if ((mdst(gamestate->board, move) ==
0 && move->capture) ||
+
284 (mdst(gamestate->board, move) !=
0 && !move->capture)) {
+
285 return INVALID_MOVE_SYNTAX;
+
286 }
+
287
+
288
+
289 _Bool chkrules;
+
290 switch (move->piece &
PIECE_MASK) {
+
291 case PAWN:
+
292 chkrules = pawn_chkrules(gamestate, move) &&
+
293 !pawn_isblocked(gamestate, move);
+
294 break;
+
295 case ROOK:
+
296 chkrules = rook_chkrules(move) &&
+
297 !rook_isblocked(gamestate, move);
+
298 break;
+
299 case KNIGHT:
+
300 chkrules = knight_chkrules(move);
+
301 break;
+
302 case BISHOP:
+
303 chkrules = bishop_chkrules(move) &&
+
304 !bishop_isblocked(gamestate, move);
+
305 break;
+
306 case QUEEN:
+
307 chkrules = queen_chkrules(move) &&
+
308 !queen_isblocked(gamestate, move);
+
309 break;
+
310 case KING:
+
311 chkrules = king_chkrules(gamestate, move) &&
+
312 !king_isblocked(gamestate, move);
+
313 break;
+
314 default:
+
315 return INVALID_MOVE_SYNTAX;
+
316 }
+
317
+
318 return chkrules ?
VALID_MOVE_SEMANTICS :
RULES_VIOLATED;
+
319 }
+
320
+
321 int validate_move(GameState *gamestate, Move *move) {
+
322
+
323 int result = validate_move_rules(gamestate, move);
+
324
+
325
+
326 if (result !=
VALID_MOVE_SEMANTICS) {
+
327 return result;
+
328 }
+
329
+
330
+
331 uint8_t piececolor = (move->piece &
COLOR_MASK);
+
332
+
333 uint8_t mykingfile =
0, mykingrow =
0, opkingfile =
0, opkingrow =
0;
+
334 for (
uint8_t row =
0 ; row <
8 ; row++) {
+
335 for (
uint8_t file =
0 ; file <
8 ; file++) {
+
336 if (gamestate->board[row][file] ==
+
337 (piececolor ==
WHITE?
WKING:
BKING)) {
+
338 mykingfile = file;
+
339 mykingrow = row;
+
340 }
else if (gamestate->board[row][file] ==
+
341 (piececolor ==
WHITE?
BKING:
WKING)) {
+
342 opkingfile = file;
+
343 opkingrow = row;
+
344 }
+
345 }
+
346 }
+
347
+
348
+
349 GameState simulation = gamestate_copy_sim(gamestate);
+
350 Move simmove = *move;
+
351 apply_move_impl(&simulation, &simmove,
1);
+
352
+
353
+
354 if (is_covered(&simulation, mykingrow, mykingfile,
+
355 opponent_color(piececolor))) {
+
356
+
357 gamestate_cleanup(&simulation);
+
358 if ((move->piece &
PIECE_MASK) ==
KING) {
+
359 return KING_MOVES_INTO_CHECK;
+
360 }
else {
+
361
+
362 return gamestate->lastmove->move.check ?
+
363 KING_IN_CHECK :
PIECE_PINNED;
+
364 }
+
365 }
+
366
+
367
+
368 Move threats[
16];
+
369 uint8_t threatcount;
+
370 move->check = get_threats(&simulation, opkingrow, opkingfile,
+
371 piececolor, threats, &threatcount);
+
372
+
373 if (move->check) {
+
374
+
375 _Bool canescape =
0;
+
376 for (
int dr = -
1 ; dr <=
1 && !canescape ; dr++) {
+
377 for (
int df = -
1 ; df <=
1 && !canescape ; df++) {
+
378 if (!(dr ==
0 && df ==
0) &&
+
379 isidx(opkingrow + dr) && isidx(opkingfile + df)) {
+
380
+
381
+
382 if ((simulation.board[opkingrow + dr][opkingfile + df]
+
383 &
COLOR_MASK) != opponent_color(piececolor)) {
+
384 canescape |= !is_covered(&simulation,
+
385 opkingrow + dr, opkingfile + df, piececolor);
+
386 }
+
387 }
+
388 }
+
389 }
+
390
+
391 if (!canescape && threatcount ==
1) {
+
392 canescape = is_attacked(&simulation, threats[
0].fromrow,
+
393 threats[
0].fromfile, opponent_color(piececolor));
+
394 }
+
395
+
396
+
397 if (!canescape && threatcount ==
1) {
+
398 Move *threat = &(threats[
0]);
+
399 uint8_t threatpiece = threat->piece &
PIECE_MASK;
+
400
+
401
+
402 if (threatpiece ==
BISHOP || threatpiece ==
ROOK
+
403 || threatpiece ==
QUEEN) {
+
404 if (threat->fromrow == threat->torow) {
+
405
+
406 int d = threat->tofile > threat->fromfile ?
1 : -
1;
+
407 uint8_t file = threat->fromfile;
+
408 while (!canescape && file != threat->tofile - d) {
+
409 file += d;
+
410 canescape |= is_protected(&simulation,
+
411 threat->torow, file, opponent_color(piececolor));
+
412 }
+
413 }
else if (threat->fromfile == threat->tofile) {
+
414
+
415 int d = threat->torow > threat->fromrow ?
1 : -
1;
+
416 uint8_t row = threat->fromrow;
+
417 while (!canescape && row != threat->torow - d) {
+
418 row += d;
+
419 canescape |= is_protected(&simulation,
+
420 row, threat->tofile, opponent_color(piececolor));
+
421 }
+
422 }
else {
+
423
+
424 int dr = threat->torow > threat->fromrow ?
1 : -
1;
+
425 int df = threat->tofile > threat->fromfile ?
1 : -
1;
+
426
+
427 uint8_t row = threat->fromrow;
+
428 uint8_t file = threat->fromfile;
+
429 while (!canescape && file != threat->tofile - df
+
430 && row != threat->torow - dr) {
+
431 row += dr;
+
432 file += df;
+
433 canescape |= is_protected(&simulation, row, file,
+
434 opponent_color(piececolor));
+
435 }
+
436 }
+
437 }
+
438 }
+
439
+
440 if (!canescape) {
+
441 gamestate->checkmate =
1;
+
442 }
+
443 }
+
444
+
445 gamestate_cleanup(&simulation);
+
446
+
447 return VALID_MOVE_SEMANTICS;
+
448 }
+
449
+
450 _Bool get_threats(GameState *gamestate,
uint8_t row,
uint8_t file,
+
451 uint8_t color, Move *threats,
uint8_t *threatcount) {
+
452 Move candidates[
32];
+
453 int candidatecount =
0;
+
454 for (
uint8_t r =
0 ; r <
8 ; r++) {
+
455 for (
uint8_t f =
0 ; f <
8 ; f++) {
+
456 if ((gamestate->board[r][f] &
COLOR_MASK) == color) {
+
457
+
458 memset(&(candidates[candidatecount]),
0,
sizeof(Move));
+
459 candidates[candidatecount].piece = gamestate->board[r][f];
+
460 candidates[candidatecount].fromrow = r;
+
461 candidates[candidatecount].fromfile = f;
+
462 candidates[candidatecount].torow = row;
+
463 candidates[candidatecount].tofile = file;
+
464 candidatecount++;
+
465
+
466
+
467 memcpy(&(candidates[candidatecount]),
+
468 &(candidates[candidatecount-
1]),
sizeof(Move));
+
469 candidates[candidatecount].capture =
1;
+
470 candidatecount++;
+
471 }
+
472 }
+
473 }
+
474
+
475 if (threatcount) {
+
476 *threatcount =
0;
+
477 }
+
478
+
479
+
480 _Bool result =
0;
+
481
+
482 for (
int i =
0 ; i < candidatecount ; i++) {
+
483 if (validate_move_rules(gamestate, &(candidates[i]))
+
484 ==
VALID_MOVE_SEMANTICS) {
+
485 result =
1;
+
486 if (threats && threatcount) {
+
487 threats[(*threatcount)++] = candidates[i];
+
488 }
+
489 }
+
490 }
+
491
+
492 return result;
+
493 }
+
494
+
495 _Bool is_pinned(GameState *gamestate, Move *move) {
+
496 uint8_t color = move->piece &
COLOR_MASK;
+
497
+
498 uint8_t kingfile =
0, kingrow =
0;
+
499 for (
uint8_t row =
0 ; row <
8 ; row++) {
+
500 for (
uint8_t file =
0 ; file <
8 ; file++) {
+
501 if (gamestate->board[row][file] == (color|
KING)) {
+
502 kingfile = file;
+
503 kingrow = row;
+
504 }
+
505 }
+
506 }
+
507
+
508 GameState simulation = gamestate_copy_sim(gamestate);
+
509 Move simmove = *move;
+
510 apply_move(&simulation, &simmove);
+
511 _Bool covered = is_covered(&simulation,
+
512 kingrow, kingfile, opponent_color(color));
+
513 gamestate_cleanup(&simulation);
+
514
+
515 return covered;
+
516 }
+
517
+
518 _Bool get_real_threats(GameState *gamestate,
uint8_t row,
uint8_t file,
+
519 uint8_t color, Move *threats,
uint8_t *threatcount) {
+
520
+
521 if (threatcount) {
+
522 *threatcount =
0;
+
523 }
+
524
+
525 Move candidates[
16];
+
526 uint8_t candidatecount;
+
527 if (get_threats(gamestate, row, file, color, candidates, &candidatecount)) {
+
528
+
529 _Bool result =
0;
+
530 uint8_t kingfile =
0, kingrow =
0;
+
531 for (
uint8_t row =
0 ; row <
8 ; row++) {
+
532 for (
uint8_t file =
0 ; file <
8 ; file++) {
+
533 if (gamestate->board[row][file] == (color|
KING)) {
+
534 kingfile = file;
+
535 kingrow = row;
+
536 }
+
537 }
+
538 }
+
539
+
540 for (
uint8_t i =
0 ; i < candidatecount ; i++) {
+
541 GameState simulation = gamestate_copy_sim(gamestate);
+
542 Move simmove = candidates[i];
+
543 apply_move(&simulation, &simmove);
+
544 if (!is_covered(&simulation, kingrow, kingfile,
+
545 opponent_color(color))) {
+
546 result =
1;
+
547 if (threats && threatcount) {
+
548 threats[(*threatcount)++] = candidates[i];
+
549 }
+
550 }
+
551 }
+
552
+
553 return result;
+
554 }
else {
+
555 return 0;
+
556 }
+
557 }
+
558
+
559 static int getlocation(GameState *gamestate, Move *move) {
+
560
+
561 uint8_t color = move->piece &
COLOR_MASK;
+
562 _Bool incheck = gamestate->lastmove?gamestate->lastmove->move.check:
0;
+
563
+
564 Move threats[
16], *threat =
NULL;
+
565 uint8_t threatcount;
+
566
+
567 if (get_threats(gamestate, move->torow, move->tofile, color,
+
568 threats, &threatcount)) {
+
569
+
570 int reason =
INVALID_POSITION;
+
571
+
572
+
573 for (
uint8_t i =
0 ; i < threatcount ; i++) {
+
574 if ((threats[i].piece & (
PIECE_MASK |
COLOR_MASK))
+
575 == move->piece &&
+
576 (move->fromrow ==
POS_UNSPECIFIED ||
+
577 move->fromrow == threats[i].fromrow) &&
+
578 (move->fromfile ==
POS_UNSPECIFIED ||
+
579 move->fromfile == threats[i].fromfile)) {
+
580
+
581 if (threat) {
+
582 return AMBIGUOUS_MOVE;
+
583 }
else {
+
584
+
585 if (is_pinned(gamestate, &(threats[i]))) {
+
586 reason = incheck?
KING_IN_CHECK:
PIECE_PINNED;
+
587 }
else {
+
588 threat = &(threats[i]);
+
589 }
+
590 }
+
591 }
+
592 }
+
593
+
594
+
595 if (!threat) {
+
596 return reason;
+
597 }
+
598
+
599 memcpy(move, threat,
sizeof(Move));
+
600 return VALID_MOVE_SYNTAX;
+
601 }
else {
+
602 return INVALID_POSITION;
+
603 }
+
604 }
+
605
+
606 int eval_move(GameState *gamestate,
char *mstr, Move *move,
uint8_t color) {
+
607 memset(move,
0,
sizeof(Move));
+
608 move->fromfile =
POS_UNSPECIFIED;
+
609 move->fromrow =
POS_UNSPECIFIED;
+
610
+
611 size_t len = strlen(mstr);
+
612 if (len <
1 || len >
6) {
+
613 return INVALID_MOVE_SYNTAX;
+
614 }
+
615
+
616
+
617 if (mstr[len-
1] ==
'+') {
+
618 len--; mstr[len] =
'\0';
+
619 move->check =
1;
+
620 }
else if (mstr[len-
1] ==
'#') {
+
621 len--; mstr[len] =
'\0';
+
622
+
623 }
+
624
+
625
+
626 if (len >
3 && mstr[len-
2] ==
'=') {
+
627 move->promotion = getpiece(mstr[len-
1]);
+
628 if (!move->promotion) {
+
629 return INVALID_MOVE_SYNTAX;
+
630 }
else {
+
631 move->promotion |= color;
+
632 len -=
2;
+
633 mstr[len] =
0;
+
634 }
+
635 }
+
636
+
637 if (len ==
2) {
+
638
+
639 move->piece =
PAWN;
+
640 move->tofile = fileidx(mstr[
0]);
+
641 move->torow = rowidx(mstr[
1]);
+
642 }
else if (len ==
3) {
+
643 if (strcmp(mstr,
"O-O") ==
0) {
+
644
+
645 move->piece =
KING;
+
646 move->fromfile = fileidx(
'e');
+
647 move->tofile = fileidx(
'g');
+
648 move->fromrow = move->torow = color ==
WHITE ?
0 :
7;
+
649 }
else {
+
650
+
651 move->piece = getpiece(mstr[
0]);
+
652 move->tofile = fileidx(mstr[
1]);
+
653 move->torow = rowidx(mstr[
2]);
+
654 }
+
655 }
else if (len ==
4) {
+
656 move->piece = getpiece(mstr[
0]);
+
657 if (!move->piece) {
+
658 move->piece =
PAWN;
+
659 move->fromfile = fileidx(mstr[
0]);
+
660 }
+
661 if (mstr[
1] ==
'x') {
+
662
+
663 move->capture =
1;
+
664 }
else {
+
665
+
666 if (isfile(mstr[
1])) {
+
667 move->fromfile = fileidx(mstr[
1]);
+
668 if (move->piece ==
PAWN) {
+
669 move->piece =
0;
+
670 }
+
671 }
else {
+
672 move->fromrow = rowidx(mstr[
1]);
+
673 }
+
674 }
+
675 move->tofile = fileidx(mstr[
2]);
+
676 move->torow = rowidx(mstr[
3]);
+
677 }
else if (len ==
5) {
+
678 if (strcmp(mstr,
"O-O-O") ==
0) {
+
679
+
680 move->piece =
KING;
+
681 move->fromfile = fileidx(
'e');
+
682 move->tofile = fileidx(
'c');
+
683 move->fromrow = move->torow = color ==
WHITE ?
0 :
7;
+
684 }
else {
+
685 move->piece = getpiece(mstr[
0]);
+
686 if (mstr[
2] ==
'x') {
+
687 move->capture =
1;
+
688 if (move->piece) {
+
689
+
690 move->fromfile = fileidx(mstr[
1]);
+
691 }
else {
+
692
+
693 move->piece =
PAWN;
+
694 move->fromfile = fileidx(mstr[
0]);
+
695 move->fromrow = rowidx(mstr[
1]);
+
696 }
+
697 }
else {
+
698
+
699 move->fromfile = fileidx(mstr[
1]);
+
700 move->fromrow = rowidx(mstr[
2]);
+
701 }
+
702 move->tofile = fileidx(mstr[
3]);
+
703 move->torow = rowidx(mstr[
4]);
+
704 }
+
705 }
else if (len ==
6) {
+
706
+
707 if (mstr[
3] ==
'x') {
+
708 move->capture =
1;
+
709 move->piece = getpiece(mstr[
0]);
+
710 move->fromfile = fileidx(mstr[
1]);
+
711 move->fromrow = rowidx(mstr[
2]);
+
712 move->tofile = fileidx(mstr[
4]);
+
713 move->torow = rowidx(mstr[
5]);
+
714 }
+
715 }
+
716
+
717
+
718 if (move->piece) {
+
719 if (move->piece ==
PAWN
+
720 && move->torow == (color==
WHITE?
7:
0)
+
721 && !move->promotion) {
+
722 return NEED_PROMOTION;
+
723 }
+
724
+
725 move->piece |= color;
+
726 if (move->fromfile ==
POS_UNSPECIFIED
+
727 || move->fromrow ==
POS_UNSPECIFIED) {
+
728 return getlocation(gamestate, move);
+
729 }
else {
+
730 return chkidx(move) ?
VALID_MOVE_SYNTAX :
INVALID_POSITION;
+
731 }
+
732 }
else {
+
733 return INVALID_MOVE_SYNTAX;
+
734 }
+
735 }
+
736
+
737 _Bool is_protected(GameState *gamestate,
uint8_t row,
uint8_t file,
+
738 uint8_t color) {
+
739
+
740 Move threats[
16];
+
741 uint8_t threatcount;
+
742 if (get_real_threats(gamestate, row, file, color, threats, &threatcount)) {
+
743 for (
int i =
0 ; i < threatcount ; i++) {
+
744 if (threats[i].piece != (color|
KING)) {
+
745 return 1;
+
746 }
+
747 }
+
748 return 0;
+
749 }
else {
+
750 return 0;
+
751 }
+
752 }
+
753
+
754 uint16_t remaining_movetime(GameInfo *gameinfo, GameState *gamestate,
+
755 uint8_t color) {
+
756 if (!gameinfo->timecontrol) {
+
757 return 0;
+
758 }
+
759
+
760 if (gamestate->movelist) {
+
761 uint16_t time = gameinfo->time;
+
762 suseconds_t micros =
0;
+
763
+
764 MoveList *movelist = color ==
WHITE ?
+
765 gamestate->movelist : gamestate->movelist->next;
+
766
+
767 while (movelist) {
+
768 time += gameinfo->addtime;
+
769
+
770 struct movetimeval *movetime = &(movelist->move.movetime);
+
771 if (movetime->tv_sec >= time) {
+
772 return 0;
+
773 }
+
774
+
775 time -= movetime->tv_sec;
+
776 micros += movetime->tv_usec;
+
777
+
778 movelist = movelist->next ? movelist->next->next :
NULL;
+
779 }
+
780
+
781 time_t sec;
+
782 movelist = gamestate->lastmove;
+
783 if ((movelist->move.piece &
COLOR_MASK) != color) {
+
784 struct movetimeval *lastmovetstamp = &(movelist->move.timestamp);
+
785 struct timeval currenttstamp;
+
786 gettimeofday(¤ttstamp,
NULL);
+
787 micros += currenttstamp.tv_usec - lastmovetstamp->tv_usec;
+
788 sec = currenttstamp.tv_sec - lastmovetstamp->tv_sec;
+
789 if (sec >= time) {
+
790 return 0;
+
791 }
+
792
+
793 time -= sec;
+
794 }
+
795
+
796 sec = micros / 1e6L;
+
797
+
798 if (sec >= time) {
+
799 return 0;
+
800 }
+
801
+
802 time -= sec;
+
803
+
804 return time;
+
805 }
else {
+
806 return gameinfo->time;
+
807 }
+
808 }
+