Failed attempt for marseilleChess with a template: back to render function
[vchess.git] / client / src / variants / Checkered.js
1 import { ChessRules } from "@/base_rules";
2
3 export const VariantRules = class CheckeredRules extends ChessRules
4 {
5 static getPpath(b)
6 {
7 return b[0]=='c' ? "Checkered/"+b : b;
8 }
9
10 static board2fen(b)
11 {
12 const checkered_codes = {
13 'p': 's',
14 'q': 't',
15 'r': 'u',
16 'b': 'c',
17 'n': 'o',
18 };
19 if (b[0]=="c")
20 return checkered_codes[b[1]];
21 return ChessRules.board2fen(b);
22 }
23
24 static fen2board(f)
25 {
26 // Tolerate upper-case versions of checkered pieces (why not?)
27 const checkered_pieces = {
28 's': 'p',
29 'S': 'p',
30 't': 'q',
31 'T': 'q',
32 'u': 'r',
33 'U': 'r',
34 'c': 'b',
35 'C': 'b',
36 'o': 'n',
37 'O': 'n',
38 };
39 if (Object.keys(checkered_pieces).includes(f))
40 return 'c'+checkered_pieces[f];
41 return ChessRules.fen2board(f);
42 }
43
44 static get PIECES()
45 {
46 return ChessRules.PIECES.concat(['s','t','u','c','o']);
47 }
48
49 setOtherVariables(fen)
50 {
51 super.setOtherVariables(fen);
52 // Local stack of non-capturing checkered moves:
53 this.cmoves = [];
54 const cmove = fen.split(" ")[5];
55 if (cmove == "-")
56 this.cmoves.push(null);
57 else
58 {
59 this.cmoves.push({
60 start: ChessRules.SquareToCoords(cmove.substr(0,2)),
61 end: ChessRules.SquareToCoords(cmove.substr(2)),
62 });
63 }
64 }
65
66 static IsGoodFen(fen)
67 {
68 if (!ChessRules.IsGoodFen(fen))
69 return false;
70 const fenParts = fen.split(" ");
71 if (fenParts.length != 6)
72 return false;
73 if (fenParts[5] != "-" && !fenParts[5].match(/^([a-h][1-8]){2}$/))
74 return false;
75 return true;
76 }
77
78 static IsGoodFlags(flags)
79 {
80 // 4 for castle + 16 for pawns
81 return !!flags.match(/^[01]{20,20}$/);
82 }
83
84 setFlags(fenflags)
85 {
86 super.setFlags(fenflags); //castleFlags
87 this.pawnFlags =
88 {
89 "w": [...Array(8).fill(true)], //pawns can move 2 squares?
90 "b": [...Array(8).fill(true)],
91 };
92 if (!fenflags)
93 return;
94 const flags = fenflags.substr(4); //skip first 4 digits, for castle
95 for (let c of ['w','b'])
96 {
97 for (let i=0; i<8; i++)
98 this.pawnFlags[c][i] = (flags.charAt((c=='w'?0:8)+i) == '1');
99 }
100 }
101
102 aggregateFlags()
103 {
104 return [this.castleFlags, this.pawnFlags];
105 }
106
107 disaggregateFlags(flags)
108 {
109 this.castleFlags = flags[0];
110 this.pawnFlags = flags[1];
111 }
112
113 getCmove(move)
114 {
115 if (move.appear[0].c == 'c' && move.vanish.length == 1)
116 return {start: move.start, end: move.end};
117 return null;
118 }
119
120 canTake([x1,y1], [x2,y2])
121 {
122 const color1 = this.getColor(x1,y1);
123 const color2 = this.getColor(x2,y2);
124 // Checkered aren't captured
125 return color1 != color2 && color2 != 'c' && (color1 != 'c' || color2 != this.turn);
126 }
127
128 // Post-processing: apply "checkerization" of standard moves
129 getPotentialMovesFrom([x,y])
130 {
131 let standardMoves = super.getPotentialMovesFrom([x,y]);
132 const lastRank = this.turn == "w" ? 0 : 7;
133 if (this.getPiece(x,y) == V.KING)
134 return standardMoves; //king has to be treated differently (for castles)
135 let moves = [];
136 standardMoves.forEach(m => {
137 if (m.vanish[0].p == V.PAWN)
138 {
139 if (Math.abs(m.end.x-m.start.x)==2 && !this.pawnFlags[this.turn][m.start.y])
140 return; //skip forbidden 2-squares jumps
141 if (this.board[m.end.x][m.end.y] == V.EMPTY && m.vanish.length==2
142 && this.getColor(m.start.x,m.start.y) == 'c')
143 {
144 return; //checkered pawns cannot take en-passant
145 }
146 }
147 if (m.vanish.length == 1)
148 moves.push(m); //no capture
149 else
150 {
151 // A capture occured (m.vanish.length == 2)
152 m.appear[0].c = "c";
153 moves.push(m);
154 if (m.appear[0].p != m.vanish[1].p //avoid promotions (already treated):
155 && (m.vanish[0].p != V.PAWN || m.end.x != lastRank))
156 {
157 // Add transformation into captured piece
158 let m2 = JSON.parse(JSON.stringify(m));
159 m2.appear[0].p = m.vanish[1].p;
160 moves.push(m2);
161 }
162 }
163 });
164 return moves;
165 }
166
167 canIplay(side, [x,y])
168 {
169 return (side == this.turn && [side,'c'].includes(this.getColor(x,y)));
170 }
171
172 // Does m2 un-do m1 ? (to disallow undoing checkered moves)
173 oppositeMoves(m1, m2)
174 {
175 return (!!m1 && m2.appear[0].c == 'c'
176 && m2.appear.length == 1 && m2.vanish.length == 1
177 && m1.start.x == m2.end.x && m1.end.x == m2.start.x
178 && m1.start.y == m2.end.y && m1.end.y == m2.start.y);
179 }
180
181 filterValid(moves)
182 {
183 if (moves.length == 0)
184 return [];
185 const color = this.turn;
186 return moves.filter(m => {
187 const L = this.cmoves.length; //at least 1: init from FEN
188 if (this.oppositeMoves(this.cmoves[L-1], m))
189 return false;
190 this.play(m);
191 const res = !this.underCheck(color);
192 this.undo(m);
193 return res;
194 });
195 }
196
197 isAttackedByPawn([x,y], colors)
198 {
199 for (let c of colors)
200 {
201 const color = (c=="c" ? this.turn : c);
202 let pawnShift = (color=="w" ? 1 : -1);
203 if (x+pawnShift>=0 && x+pawnShift<8)
204 {
205 for (let i of [-1,1])
206 {
207 if (y+i>=0 && y+i<8 && this.getPiece(x+pawnShift,y+i)==V.PAWN
208 && this.getColor(x+pawnShift,y+i)==c)
209 {
210 return true;
211 }
212 }
213 }
214 }
215 return false;
216 }
217
218 underCheck(color)
219 {
220 return this.isAttacked(this.kingPos[color], [V.GetOppCol(color),'c']);
221 }
222
223 getCheckSquares(color)
224 {
225 // Artifically change turn, for checkered pawns
226 this.turn = V.GetOppCol(color);
227 const kingAttacked = this.isAttacked(
228 this.kingPos[color], [V.GetOppCol(color),'c']);
229 let res = kingAttacked
230 ? [JSON.parse(JSON.stringify(this.kingPos[color]))] //need to duplicate!
231 : [];
232 this.turn = color;
233 return res;
234 }
235
236 updateVariables(move)
237 {
238 super.updateVariables(move);
239 // Does this move turn off a 2-squares pawn flag?
240 const secondRank = [1,6];
241 if (secondRank.includes(move.start.x) && move.vanish[0].p == V.PAWN)
242 this.pawnFlags[move.start.x==6 ? "w" : "b"][move.start.y] = false;
243 }
244
245 getCurrentScore()
246 {
247 if (this.atLeastOneMove()) // game not over
248 return "*";
249
250 const color = this.turn;
251 // Artifically change turn, for checkered pawns
252 this.turn = V.GetOppCol(this.turn);
253 const res = this.isAttacked(this.kingPos[color], [V.GetOppCol(color),'c'])
254 ? (color == "w" ? "0-1" : "1-0")
255 : "1/2";
256 this.turn = V.GetOppCol(this.turn);
257 return res;
258 }
259
260 evalPosition()
261 {
262 let evaluation = 0;
263 //Just count material for now, considering checkered neutral (...)
264 for (let i=0; i<V.size.x; i++)
265 {
266 for (let j=0; j<V.size.y; j++)
267 {
268 if (this.board[i][j] != V.EMPTY)
269 {
270 const sqColor = this.getColor(i,j);
271 const sign = sqColor == "w" ? 1 : (sqColor=="b" ? -1 : 0);
272 evaluation += sign * V.VALUES[this.getPiece(i,j)];
273 }
274 }
275 }
276 return evaluation;
277 }
278
279 static GenRandInitFen()
280 {
281 const randFen = ChessRules.GenRandInitFen();
282 // Add 16 pawns flags + empty cmove:
283 return randFen.replace(" w 0 1111", " w 0 11111111111111111111 -");
284 }
285
286 static ParseFen(fen)
287 {
288 const fenParsed = ChessRules.ParseFen(fen);
289 return Object.assign({},
290 ChessRules.ParseFen(fen),
291 {cmove: fen.split(" ")[5]});
292 }
293
294 getFen()
295 {
296 const L = this.cmoves.length;
297 const cmoveFen = (!this.cmoves[L-1]
298 ? "-"
299 : ChessRules.CoordsToSquare(this.cmoves[L-1].start)
300 + ChessRules.CoordsToSquare(this.cmoves[L-1].end));
301 return super.getFen() + " " + cmoveFen;
302 }
303
304 getFlagsFen()
305 {
306 let fen = super.getFlagsFen();
307 // Add pawns flags
308 for (let c of ['w','b'])
309 {
310 for (let i=0; i<8; i++)
311 fen += this.pawnFlags[c][i] ? '1' : '0';
312 }
313 return fen;
314 }
315
316 // TODO (design): this cmove update here or in (un)updateVariables ?
317 play(move)
318 {
319 this.cmoves.push( this.getCmove(move) );
320 super.play(move);
321 }
322
323 undo(move)
324 {
325 this.cmoves.pop();
326 super.undo(move);
327 }
328
329 getNotation(move)
330 {
331 if (move.appear.length == 2)
332 {
333 // Castle
334 if (move.end.y < move.start.y)
335 return "0-0-0";
336 else
337 return "0-0";
338 }
339
340 // Translate final square
341 const finalSquare = V.CoordsToSquare(move.end);
342
343 const piece = this.getPiece(move.start.x, move.start.y);
344 if (piece == V.PAWN)
345 {
346 // Pawn move
347 let notation = "";
348 if (move.vanish.length > 1)
349 {
350 // Capture
351 const startColumn = V.CoordToColumn(move.start.y);
352 notation = startColumn + "x" + finalSquare +
353 "=" + move.appear[0].p.toUpperCase();
354 }
355 else //no capture
356 {
357 notation = finalSquare;
358 if (move.appear.length > 0 && piece != move.appear[0].p) //promotion
359 notation += "=" + move.appear[0].p.toUpperCase();
360 }
361 return notation;
362 }
363
364 else
365 {
366 // Piece movement
367 return piece.toUpperCase() + (move.vanish.length > 1 ? "x" : "") + finalSquare
368 + (move.vanish.length > 1 ? "=" + move.appear[0].p.toUpperCase() : "");
369 }
370 }
371 }