Commit | Line | Data |
---|---|---|
305ede7e BA |
1 | import { ChessRules, PiPo } from "@/base_rules"; |
2 | ||
3 | export class SchessRules extends ChessRules { | |
4 | static get PawnSpecs() { | |
5 | return Object.assign( | |
6 | {}, | |
7 | ChessRules.PawnSpecs, | |
8 | { | |
9 | promotions: | |
10 | ChessRules.PawnSpecs.promotions.concat([V.HAWK, V.ELEPHANT]) | |
11 | } | |
12 | ); | |
13 | } | |
14 | ||
15 | static get HAWK() { | |
16 | return 'h'; | |
17 | } | |
18 | ||
19 | static get ELEPHANT() { | |
20 | return 'e'; | |
21 | } | |
22 | ||
23 | static get PIECES() { | |
24 | return ChessRules.PIECES.concat([V.HAWK, V.ELEPHANT]); | |
25 | } | |
26 | ||
27 | getPpath(b) { | |
28 | if ([V.HAWK, V.ELEPHANT].includes(b[1])) return "Schess/" + b; | |
29 | return b; | |
30 | } | |
31 | ||
32 | // TODO: maybe changes could be done to this method to show "empty" | |
33 | // instead of a piece to not use a pocket piece... | |
34 | // getPPpath(b) { } | |
35 | ||
36 | static IsGoodFen(fen) { | |
37 | if (!ChessRules.IsGoodFen(fen)) return false; | |
38 | const fenParsed = V.ParseFen(fen); | |
39 | // Check pocket state | |
40 | if (!fenParsed.pocket || !fenParsed.pocket.match(/^[0-1]{4,4}$/)) | |
41 | return false; | |
42 | return true; | |
43 | } | |
44 | ||
45 | static IsGoodFlags(flags) { | |
46 | // 4 for castle + 16 for generators | |
47 | return !!flags.match(/^[a-z]{4,4}[01]{16,16}$/); | |
48 | } | |
49 | ||
50 | setFlags(fenflags) { | |
51 | super.setFlags(fenflags); //castleFlags | |
52 | this.pieceFlags = { | |
53 | w: [...Array(8)], //pawns can move 2 squares? | |
54 | b: [...Array(8)] | |
55 | }; | |
56 | const flags = fenflags.substr(4); //skip first 4 letters, for castle | |
57 | for (let c of ["w", "b"]) { | |
58 | for (let i = 0; i < 8; i++) | |
59 | this.pieceFlags[c][i] = flags.charAt((c == "w" ? 0 : 8) + i) == "1"; | |
60 | } | |
61 | } | |
62 | ||
63 | aggregateFlags() { | |
64 | return [this.castleFlags, this.pieceFlags]; | |
65 | } | |
66 | ||
67 | disaggregateFlags(flags) { | |
68 | this.castleFlags = flags[0]; | |
69 | this.pieceFlags = flags[1]; | |
70 | } | |
71 | ||
72 | static ParseFen(fen) { | |
73 | const fenParts = fen.split(" "); | |
74 | return Object.assign( | |
75 | ChessRules.ParseFen(fen), | |
76 | { pocket: fenParts[5] } | |
77 | ); | |
78 | } | |
79 | ||
80 | static GenRandInitFen(randomness) { | |
81 | return ( | |
82 | ChessRules.GenRandInitFen(randomness).slice(0, -2) + | |
83 | // Add pieceFlags + pocket | |
84 | "1111111111111111 - 1111" | |
85 | ); | |
86 | } | |
87 | ||
88 | getFen() { | |
89 | return ( | |
90 | super.getFen() + " " + | |
91 | this.getPocketFen() | |
92 | ); | |
93 | } | |
94 | ||
95 | getFenForRepeat() { | |
96 | return ( | |
97 | super.getFenForRepeat() + "_" + | |
98 | this.getPocketFen() | |
99 | ); | |
100 | } | |
101 | ||
102 | getFlagsFen() { | |
103 | let fen = super.getFlagsFen(); | |
104 | // Add pieces flags | |
105 | for (let c of ["w", "b"]) | |
106 | for (let i = 0; i < 8; i++) fen += (this.pieceFlags[c][i] ? "1" : "0"); | |
107 | return fen; | |
108 | } | |
109 | ||
110 | getPocketFen() { | |
111 | let res = ""; | |
112 | for (let c of ["w", "b"]) | |
113 | res += this.pocket[c][V.HAWK] + this.pocket[c][V.ELEPHANT]; | |
114 | return res; | |
115 | } | |
116 | ||
117 | setOtherVariables(fen) { | |
118 | super.setOtherVariables(fen); | |
119 | const fenParsed = V.ParseFen(fen); | |
120 | this.pocket = { | |
121 | "w": { | |
122 | h: parseInt(fenParsed.pocket[0]), | |
123 | e: parseInt(fenParsed.pocket[1]) | |
124 | }, | |
125 | "b": { | |
126 | h: parseInt(fenParsed.pocket[2]), | |
127 | e: parseInt(fenParsed.pocket[3]) | |
128 | } | |
129 | }; | |
130 | } | |
131 | ||
132 | getPotentialMovesFrom([x, y]) { | |
133 | let moves = undefined; | |
134 | switch (this.getPiece(x, y)) { | |
135 | case V.HAWK: | |
136 | moves = this.getPotentialHawkMoves([x, y]); | |
137 | break; | |
138 | case V.ELEPHANT: | |
139 | moves = this.getPotentialElephantMoves([x, y]); | |
140 | break; | |
141 | default: | |
142 | moves = super.getPotentialMovesFrom([x, y]); | |
143 | } | |
144 | // Post-processing: add choices for hawk and elephant, | |
145 | // except for moves letting the king under check. | |
146 | const color = this.turn; | |
147 | if (Object.values(this.pocket[color]).some(v => v > 0)) { | |
148 | const firstRank = (color == "w" ? 7 : 0); | |
149 | let pocketMoves = []; | |
150 | moves.forEach(m => { | |
151 | let inCheckAfter = false; | |
152 | this.play(m); | |
153 | if (this.underCheck(color)) inCheckAfter = true; | |
154 | this.undo(m); | |
155 | if (!inCheckAfter) { | |
156 | for (let pp of ['h', 'e']) { | |
157 | if (this.pocket[color][pp] > 0) { | |
158 | if ( | |
159 | m.start.x == firstRank && | |
160 | this.pieceFlags[color][m.start.y] && | |
161 | ( | |
162 | m.appear.length == 1 || | |
163 | // Special castle case: is initial king square free? | |
164 | ![m.appear[0].y, m.appear[1].y].includes(m.vanish[0].y) | |
165 | ) | |
166 | ) { | |
167 | let pMove = JSON.parse(JSON.stringify(m)); | |
168 | // NOTE: unshift instead of push, for choices presentation | |
169 | pMove.appear.unshift(new PiPo({ | |
170 | p: pp, | |
171 | c: color, | |
172 | x: x, | |
173 | y: y | |
174 | })); | |
175 | pocketMoves.push(pMove); | |
176 | } | |
177 | if ( | |
178 | m.appear.length == 2 && | |
179 | ![m.appear[0].y, m.appear[1].y].includes(m.vanish[1].y) | |
180 | ) { | |
181 | // Special castle case: rook flag was necessarily on | |
182 | let pMove = JSON.parse(JSON.stringify(m)); | |
183 | pMove.appear.unshift(new PiPo({ | |
184 | p: pp, | |
185 | c: color, | |
186 | x: m.vanish[1].x, | |
187 | y: m.vanish[1].y | |
188 | })); | |
189 | pocketMoves.push(pMove); | |
190 | } | |
191 | } | |
192 | } | |
193 | } | |
194 | }); | |
195 | // NOTE: the order matter, for presentation on screen | |
196 | moves = moves.concat(pocketMoves); | |
197 | } | |
198 | return moves; | |
199 | } | |
200 | ||
201 | getPotentialHawkMoves(sq) { | |
40ac07d9 BA |
202 | return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]).concat( |
203 | this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep") | |
305ede7e BA |
204 | ); |
205 | } | |
206 | ||
207 | getPotentialElephantMoves(sq) { | |
40ac07d9 BA |
208 | return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat( |
209 | this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep") | |
305ede7e BA |
210 | ); |
211 | } | |
212 | ||
213 | isAttacked(sq, color) { | |
214 | return ( | |
215 | super.isAttacked(sq, color) || | |
216 | this.isAttackedByHawk(sq, color) || | |
217 | this.isAttackedByElephant(sq, color) | |
218 | ); | |
219 | } | |
220 | ||
221 | isAttackedByHawk(sq, color) { | |
40ac07d9 BA |
222 | return ( |
223 | this.isAttackedBySlideNJump(sq, color, V.HAWK, V.steps[V.BISHOP]) || | |
224 | this.isAttackedBySlideNJump( | |
225 | sq, | |
226 | color, | |
227 | V.HAWK, | |
228 | V.steps[V.KNIGHT], | |
229 | "oneStep" | |
230 | ) | |
305ede7e BA |
231 | ); |
232 | } | |
233 | ||
234 | isAttackedByElephant(sq, color) { | |
40ac07d9 BA |
235 | return ( |
236 | this.isAttackedBySlideNJump(sq, color, V.ELEPHANT, V.steps[V.ROOK]) || | |
237 | this.isAttackedBySlideNJump( | |
238 | sq, | |
239 | color, | |
240 | V.ELEPHANT, | |
241 | V.steps[V.KNIGHT], | |
242 | "oneStep" | |
243 | ) | |
305ede7e BA |
244 | ); |
245 | } | |
246 | ||
247 | prePlay(move) { | |
248 | super.prePlay(move); | |
249 | if (move.appear.length >= 2) { | |
250 | if ([V.HAWK, V.ELEPHANT].includes(move.appear[0].p)) { | |
251 | // A pocket piece is used | |
252 | const color = this.turn; | |
253 | this.pocket[color][move.appear[0].p] = 0; | |
254 | } | |
255 | } | |
256 | } | |
257 | ||
258 | postPlay(move) { | |
259 | super.postPlay(move); | |
260 | const color = move.vanish[0].c; | |
261 | const oppCol = V.GetOppCol(color); | |
262 | const firstRank = (color == 'w' ? 7 : 0); | |
263 | const oppFirstRank = 7 - firstRank; | |
264 | // Does this move turn off a piece init square flag? | |
265 | if (move.start.x == firstRank) { | |
266 | if (this.pieceFlags[color][move.start.y]) | |
267 | this.pieceFlags[color][move.start.y] = false; | |
268 | // Special castle case: | |
269 | if (move.appear.length >= 2) { | |
270 | const L = move.appear.length; | |
271 | if (move.appear[L-1].p == V.ROOK) | |
272 | this.pieceFlags[color][move.vanish[1].y] = false; | |
273 | } | |
274 | } | |
275 | if (move.end.x == oppFirstRank && this.pieceFlags[oppCol][move.end.y]) | |
276 | this.pieceFlags[oppCol][move.end.y] = false; | |
277 | } | |
278 | ||
279 | postUndo(move) { | |
280 | super.postUndo(move); | |
281 | if (move.appear.length >= 2) { | |
282 | if ([V.HAWK, V.ELEPHANT].includes(move.appear[0].p)) { | |
283 | // A pocket piece was used | |
284 | const color = this.turn; | |
285 | this.pocket[color][move.appear[0].p] = 1; | |
286 | } | |
287 | } | |
288 | } | |
289 | ||
290 | static get SEARCH_DEPTH() { | |
291 | return 2; | |
292 | } | |
293 | ||
294 | static get VALUES() { | |
295 | return Object.assign( | |
296 | {}, | |
297 | ChessRules.VALUES, | |
298 | { 'h': 5, 'e': 7 } | |
299 | ); | |
300 | } | |
301 | ||
302 | getNotation(move) { | |
303 | if ( | |
304 | move.appear.length >= 2 && | |
305 | [V.HAWK, V.ELEPHANT].includes(move.appear[0].p) | |
306 | ) { | |
307 | const suffix = "/" + move.appear[0].p.toUpperCase(); | |
308 | let cmove = JSON.parse(JSON.stringify(move)); | |
309 | cmove.appear.shift(); | |
310 | return super.getNotation(cmove) + suffix; | |
311 | } | |
312 | return super.getNotation(move); | |
313 | } | |
314 | }; |