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