32 |
32 |
33 _Bool rook_chkrules(Move *move) { |
33 _Bool rook_chkrules(Move *move) { |
34 return move->torow == move->fromrow || move->tofile == move->fromfile; |
34 return move->torow == move->fromrow || move->tofile == move->fromfile; |
35 } |
35 } |
36 |
36 |
37 _Bool rook_isblocked(Board board, Move *move) { |
37 _Bool rook_isblocked(GameState *gamestate, Move *move) { |
38 |
38 |
39 if (move->torow == move->fromrow) { |
39 if (move->torow == move->fromrow) { |
40 int d = move->tofile > move->fromfile ? 1 : -1; |
40 int d = move->tofile > move->fromfile ? 1 : -1; |
41 uint8_t f = move->fromfile; |
41 uint8_t f = move->fromfile; |
42 while (f != move->tofile-d) { |
42 while (f != move->tofile-d) { |
43 f += d; |
43 f += d; |
44 if (board[move->fromrow][f]) { |
44 if (gamestate->board[move->fromrow][f]) { |
45 return 1; |
45 return 1; |
46 } |
46 } |
47 } |
47 } |
48 } else { |
48 } else { |
49 int d = move->torow > move->fromrow ? 1 : -1; |
49 int d = move->torow > move->fromrow ? 1 : -1; |
50 uint8_t r = move->fromrow; |
50 uint8_t r = move->fromrow; |
51 while (r != move->torow - d) { |
51 while (r != move->torow - d) { |
52 r += d; |
52 r += d; |
53 if (board[r][move->fromfile]) { |
53 if (gamestate->board[r][move->fromfile]) { |
54 return 1; |
54 return 1; |
55 } |
55 } |
56 } |
56 } |
57 } |
57 } |
58 |
58 |
59 return 0; |
59 return 0; |
60 } |
60 } |
61 |
61 |
62 static int rook_getloc_fixedrow(Board board, Move *move) { |
62 static int rook_getloc_fixedrow(GameState *gamestate, Move *move) { |
63 uint8_t file = POS_UNSPECIFIED; |
63 uint8_t file = POS_UNSPECIFIED; |
64 for (uint8_t f = 0 ; f < 8 ; f++) { |
64 for (uint8_t f = 0 ; f < 8 ; f++) { |
65 if (board[move->fromrow][f] == move->piece) { |
65 if (gamestate->board[move->fromrow][f] == move->piece) { |
66 if (file == POS_UNSPECIFIED) { |
66 if (file == POS_UNSPECIFIED) { |
67 file = f; |
67 file = f; |
68 } else { |
68 } else { |
69 return AMBIGUOUS_MOVE; |
69 return AMBIGUOUS_MOVE; |
70 } |
70 } |
76 move->fromfile = file; |
76 move->fromfile = file; |
77 return VALID_MOVE_SYNTAX; |
77 return VALID_MOVE_SYNTAX; |
78 } |
78 } |
79 } |
79 } |
80 |
80 |
81 static int rook_getloc_fixedfile(Board board, Move *move) { |
81 static int rook_getloc_fixedfile(GameState *gamestate, Move *move) { |
82 uint8_t row = POS_UNSPECIFIED; |
82 uint8_t row = POS_UNSPECIFIED; |
83 for (uint8_t r = 0 ; r < 8 ; r++) { |
83 for (uint8_t r = 0 ; r < 8 ; r++) { |
84 if (board[r][move->fromfile] == move->piece) { |
84 if (gamestate->board[r][move->fromfile] == move->piece) { |
85 if (row == POS_UNSPECIFIED) { |
85 if (row == POS_UNSPECIFIED) { |
86 row = r; |
86 row = r; |
87 } else { |
87 } else { |
88 return AMBIGUOUS_MOVE; |
88 return AMBIGUOUS_MOVE; |
89 } |
89 } |
95 move->fromrow = row; |
95 move->fromrow = row; |
96 return VALID_MOVE_SYNTAX; |
96 return VALID_MOVE_SYNTAX; |
97 } |
97 } |
98 } |
98 } |
99 |
99 |
100 int rook_getlocation(Board board, Move *move) { |
100 int rook_getlocation(GameState *gamestate, Move *move) { |
101 |
101 |
102 if (move->fromfile != POS_UNSPECIFIED) { |
102 if (move->fromfile != POS_UNSPECIFIED) { |
103 if (move->fromfile == move->tofile) { |
103 if (move->fromfile == move->tofile) { |
104 return rook_getloc_fixedfile(board, move); |
104 return rook_getloc_fixedfile(gamestate, move); |
105 } else { |
105 } else { |
106 if (board[move->torow][move->fromfile] == move->piece) { |
106 if (gamestate->board[move->torow][move->fromfile] == move->piece) { |
107 move->fromrow = move->torow; |
107 move->fromrow = move->torow; |
108 return VALID_MOVE_SYNTAX; |
108 return VALID_MOVE_SYNTAX; |
109 } else { |
109 } else { |
110 return INVALID_POSITION; |
110 return INVALID_POSITION; |
111 } |
111 } |
112 } |
112 } |
113 } |
113 } |
114 |
114 |
115 if (move->fromrow != POS_UNSPECIFIED) { |
115 if (move->fromrow != POS_UNSPECIFIED) { |
116 if (move->fromrow == move->torow) { |
116 if (move->fromrow == move->torow) { |
117 return rook_getloc_fixedrow(board, move); |
117 return rook_getloc_fixedrow(gamestate, move); |
118 } else { |
118 } else { |
119 if (board[move->fromrow][move->tofile] == move->piece) { |
119 if (gamestate->board[move->fromrow][move->tofile] == move->piece) { |
120 move->fromfile = move->tofile; |
120 move->fromfile = move->tofile; |
121 return VALID_MOVE_SYNTAX; |
121 return VALID_MOVE_SYNTAX; |
122 } else { |
122 } else { |
123 return INVALID_POSITION; |
123 return INVALID_POSITION; |
124 } |
124 } |
126 } |
126 } |
127 |
127 |
128 Move chkrowmove = *move, chkfilemove = *move; |
128 Move chkrowmove = *move, chkfilemove = *move; |
129 |
129 |
130 chkrowmove.fromrow = move->torow; |
130 chkrowmove.fromrow = move->torow; |
131 int chkrow = rook_getloc_fixedrow(board, &chkrowmove); |
131 int chkrow = rook_getloc_fixedrow(gamestate, &chkrowmove); |
132 |
132 |
133 chkfilemove.fromfile = move->tofile; |
133 chkfilemove.fromfile = move->tofile; |
134 int chkfile = rook_getloc_fixedfile(board, &chkfilemove); |
134 int chkfile = rook_getloc_fixedfile(gamestate, &chkfilemove); |
135 |
135 |
136 if ((chkrow == VALID_MOVE_SYNTAX && chkfile == VALID_MOVE_SYNTAX) || |
136 if ((chkrow == VALID_MOVE_SYNTAX && chkfile == VALID_MOVE_SYNTAX) || |
137 chkrow == AMBIGUOUS_MOVE || chkfile == AMBIGUOUS_MOVE) { |
137 chkrow == AMBIGUOUS_MOVE || chkfile == AMBIGUOUS_MOVE) { |
138 return AMBIGUOUS_MOVE; |
138 return AMBIGUOUS_MOVE; |
139 } |
139 } |