A few fixes, specify Apocalypse rules, draft Arena
[xogo.git] / variants / Apocalypse / class.js
1 import ChessRules from "/base_rules.js";
2 import {ArrayFun} from "/utils/array.js";
3
4 export default class ApocalypseRules extends ChessRules {
5
6 static get Options() {
7 return {};
8 }
9
10 get hasFlags() {
11 return false;
12 }
13 get hasEnpassant() {
14 return false;
15 }
16 get hideMoves() {
17 return true;
18 }
19
20 get pawnPromotions() {
21 return ['n', 'p'];
22 }
23
24 get size() {
25 return {x: 5, y: 5};
26 }
27
28 setOtherVariables(fenParsed) {
29 super.setOtherVariables(fenParsed);
30 // Often a simple move, but sometimes an array (pawn relocation)
31 this.whiteMove = fenParsed.whiteMove != "-"
32 ? JSON.parse(fenParsed.whiteMove)
33 : [];
34 this.firstMove = null; //used if black turn pawn relocation
35 this.penalties = ArrayFun.toObject(
36 ['w', 'b'],
37 [0, 1].map(i => parseInt(fenParsed.penalties.charAt(i), 10))
38 );
39 }
40
41 genRandInitBaseFen() {
42 return {
43 fen: "npppn/p3p/5/P3P/NPPPN w 0",
44 o: {}
45 };
46 }
47
48 getPartFen(o) {
49 return {
50 whiteMove: (o.init || !this.whiteMove) ? "-" : this.whiteMove,
51 penalties: o.init ? "00" : Object.values(this.penalties).join("")
52 };
53 }
54
55 getWhitemoveFen() {
56 if (this.whiteMove.length == 0)
57 return "-";
58 if (this.whiteMove.length == 1)
59 return JSON.stringify(this.whiteMove[0]);
60 return JSON.stringify(this.whiteMove); //pawn relocation
61 }
62
63 // Allow pawns to move diagonally and capture vertically,
64 // because some of these moves might be valid a posteriori.
65 // They will be flagged as 'illegal' in a first time, however.
66 pieces(color, x, y) {
67 const pawnShift = (color == "w" ? -1 : 1);
68 return {
69 'p': {
70 "class": "pawn",
71 moves: [
72 {
73 steps: [[pawnShift, 0], [pawnShift, -1], [pawnShift, 1]],
74 range: 1
75 }
76 ],
77 },
78 'n': super.pieces(color, x, y)['n']
79 };
80 }
81
82 // Allow self-captures, because they might be valid
83 // if opponent takes on the same square (luck...)
84 canTake() {
85 return true;
86 }
87
88 getPotentialMovesFrom([x, y]) {
89 let moves = [];
90 if (this.subTurn == 2) {
91 const start = this.firstMove.end;
92 if (x == start.x && y == start.y) {
93 // Move the pawn to any empty square not on last rank (== x)
94 for (let i=0; i<this.size.x; i++) {
95 if (i == x)
96 continue;
97 for (let j=0; j<this.size.y; j++) {
98 if (this.board[i][j] == "")
99 moves.push(this.getBasicMove([x, y], [i, j]));
100 }
101 }
102 }
103 }
104 else {
105 const oppCol = C.GetOppCol(this.getColor(x, y));
106 moves = super.getPotentialMovesFrom([x, y]).filter(m => {
107 // Remove pawn push toward own color (absurd)
108 return (
109 m.vanish[0].p != 'p' ||
110 m.end.y != m.start.y ||
111 m.vanish.length == 1 ||
112 m.vanish[1].c == oppCol
113 );
114 });
115 // Flag a priori illegal moves
116 moves.forEach(m => {
117 if (
118 // Self-capture test:
119 (m.vanish.length == 2 && m.vanish[1].c == m.vanish[0].c) ||
120 // Pawn going diagonaly to empty square, or vertically to occupied
121 (
122 m.vanish[0].p == 'p' &&
123 (
124 (m.end.y == m.start.y && m.vanish.length == 2) ||
125 (m.end.y != m.start.y && m.vanish.length == 1)
126 )
127 )
128 ) {
129 m.illegal = true;
130 }
131 });
132 }
133 return moves;
134 }
135
136 pawnPostProcess(moves, color, oppCol) {
137 let knightCount = 0;
138 for (let i=0; i<this.size.x; i++) {
139 for (let j=0; j<this.size.y; j++) {
140 if (
141 this.board[i][j] != "" &&
142 this.getColor(i, j) == color &&
143 this.getPiece(i, j) == 'n'
144 ) {
145 knightCount++;
146 }
147 }
148 }
149 return super.pawnPostProcess(moves, color, oppCol).filter(m => {
150 if (
151 m.vanish[0].p == 'p' &&
152 (
153 (color == 'w' && m.end.x == 0) ||
154 (color == 'b' && m.end.x == this.size.x - 1)
155 )
156 ) {
157 // Pawn promotion
158 if (knightCount <= 1 && m.appear[0].p == 'p')
159 return false; //knight promotion mandatory
160 if (knightCount == 2 && m.appear[0].p == 'n')
161 m.illegal = true; //will be legal only if one knight is captured
162 }
163 return true;
164 });
165 }
166
167 filterValid(moves) {
168 // No checks:
169 return moves;
170 }
171
172 // White and black (partial) moves were played: merge
173 resolveSynchroneMove(move) {
174 const condensate = (mArr) => {
175 const illegal = (mArr.length == 1 && mArr[0].illegal) ||
176 (!mArr[0] && mArr[1].illegal);
177 if (mArr.length == 1)
178 return Object.assign({illegal: illegal}, mArr[0]);
179 if (!mArr[0])
180 return Object.assign({illegal: illegal}, mArr[1]);
181 // Pawn relocation
182 return {
183 start: mArr[0].start,
184 end: mArr[1].end,
185 vanish: mArr[0].vanish,
186 appear: mArr[1].appear,
187 segments: [
188 [[mArr[0].start.x, mArr[0].start.y], [mArr[0].end.x, mArr[0].end.y]],
189 [[mArr[1].start.x, mArr[1].start.y], [mArr[1].end.x, mArr[1].end.y]]
190 ]
191 };
192 };
193 const compatible = (m1, m2) => {
194 if (m2.illegal)
195 return false;
196 // Knight promotion?
197 if (m1.appear[0].p != m1.vanish[0].p)
198 return m2.vanish.length == 2 && m2.vanish[1].p == 'n';
199 if (
200 // Self-capture attempt?
201 (m1.vanish.length == 2 && m1.vanish[1].c == m1.vanish[0].c) ||
202 // Pawn captures something by anticipation?
203 (
204 m1.vanish[0].p == 'p' &&
205 m1.vanish.length == 1 &&
206 m1.start.y != m1.end.y
207 )
208 ) {
209 return m2.end.x == m1.end.x && m2.end.y == m1.end.y;
210 }
211 // Pawn push toward an enemy piece?
212 if (
213 m1.vanish[0].p == 'p' &&
214 m1.vanish.length == 2 &&
215 m1.start.y == m1.end.y
216 ) {
217 return m2.start.x == m1.end.x && m2.start.y == m1.end.y;
218 }
219 return true;
220 };
221 const adjust = (res) => {
222 if (!res.wm || !res.bm)
223 return;
224 for (let c of ['w', 'b']) {
225 const myMove = res[c + 'm'], oppMove = res[C.GetOppCol(c) + 'm'];
226 if (
227 myMove.end.x == oppMove.start.x &&
228 myMove.end.y == oppMove.start.y
229 ) {
230 // Whatever was supposed to vanish, finally doesn't vanish
231 myMove.vanish.pop();
232 }
233 }
234 if (res.wm.end.y == res.bm.end.y && res.wm.end.x == res.bm.end.x) {
235 // Collision (necessarily on empty square)
236 if (!res.wm.illegal && !res.bm.illegal) {
237 if (res.wm.vanish[0].p != res.bm.vanish[0].p) {
238 const c = (res.wm.vanish[0].p == 'n' ? 'w' : 'b');
239 res[c + 'm'].vanish.push(res[C.GetOppCol(c) + 'm'].appear.shift());
240 }
241 else {
242 // Collision of two pieces of same nature: both disappear
243 res.wm.appear.shift();
244 res.bm.appear.shift();
245 }
246 }
247 else {
248 const c = (!res.wm.illegal ? 'w' : 'b');
249 // Illegal move wins:
250 res[c + 'm'].appear.shift();
251 }
252 }
253 };
254 // Clone moves to avoid altering them:
255 let whiteMove = JSON.parse(JSON.stringify(this.whiteMove)),
256 blackMove = JSON.parse(JSON.stringify([this.firstMove, move]));
257 [whiteMove, blackMove] = [condensate(whiteMove), condensate(blackMove)];
258 let res = {
259 wm: (
260 (!whiteMove.illegal || compatible(whiteMove, blackMove))
261 ? whiteMove
262 : null
263 ),
264 bm: (
265 (!blackMove.illegal || compatible(blackMove, whiteMove))
266 ? blackMove
267 : null
268 )
269 };
270 adjust(res);
271 return res;
272 }
273
274 play(move) {
275 const color = this.turn;
276 if (color == 'w')
277 this.whiteMove.push(move);
278 if (
279 move.vanish[0].p == 'p' && move.appear[0].p == 'p' &&
280 (
281 (color == 'w' && move.end.x == 0) ||
282 (color == 'b' && move.end.x == this.size.x - 1)
283 )
284 ) {
285 // Pawn on last rank : will relocate
286 this.subTurn = 2;
287 this.firstMove = move;
288 if (color == this.playerColor) {
289 this.playOnBoard(move);
290 this.playVisual(move);
291 }
292 return;
293 }
294 if (color == this.playerColor && this.firstMove) {
295 // The move was played on board: undo it
296 this.undoOnBoard(this.firstMove);
297 const revFirstMove = {
298 start: this.firstMove.end,
299 end: this.firstMove.start,
300 appear: this.firstMove.vanish,
301 vanish: this.firstMove.appear
302 };
303 this.playVisual(revFirstMove);
304 }
305 this.turn = C.GetOppCol(color);
306 this.movesCount++;
307 this.subTurn = 1;
308 this.firstMove = null;
309 if (color == 'b') {
310 // A full turn just ended
311 const res = this.resolveSynchroneMove(move);
312 const callback = () => {
313 // start + end don't matter for playOnBoard() and playVisual().
314 // Merging is necessary because moves may overlap.
315 let toPlay = {appear: [], vanish: []};
316 for (let c of ['w', 'b']) {
317 if (res[c + 'm']) {
318 Array.prototype.push.apply(toPlay.vanish, res[c + 'm'].vanish);
319 Array.prototype.push.apply(toPlay.appear, res[c + 'm'].appear);
320 }
321 }
322 this.playOnBoard(toPlay);
323 this.playVisual(toPlay);
324 };
325 if (res.wm)
326 this.animate(res.wm, () => {if (!res.bm) callback();});
327 if (res.bm)
328 this.animate(res.bm, callback);
329 if (!res.wm && !res.bm) {
330 this.displayIllegalInfo("both illegal");
331 ['w', 'b'].forEach(c => this.penalties[c]++);
332 }
333 else if (!res.wm) {
334 this.displayIllegalInfo("white illegal");
335 this.penalties['w']++;
336 }
337 else if (!res.bm) {
338 this.displayIllegalInfo("black illegal");
339 this.penalties['b']++;
340 }
341 this.whiteMove = [];
342 }
343 }
344
345 displayIllegalInfo(msg) {
346 super.displayMessage(null, msg, "illegal-text", 2000);
347 }
348
349 atLeastOneLegalMove(color) {
350 for (let i=0; i<this.size.x; i++) {
351 for (let j=0; j<this.size.y; j++) {
352 if (
353 this.board[i][j] != "" &&
354 this.getColor(i, j) == color &&
355 this.getPotentialMovesFrom([i, j]).some(m => !m.illegal)
356 ) {
357 return true;
358 }
359 }
360 }
361 return false;
362 }
363
364 getCurrentScore() {
365 if (this.turn == 'b') {
366 // Turn (white + black) not over yet.
367 // Could be stalemate if black cannot move (legally):
368 if (!this.atLeastOneLegalMove('b'))
369 return "1/2";
370 return "*";
371 }
372 // Count footmen: if a side has none, it loses
373 let fmCount = { 'w': 0, 'b': 0 };
374 for (let i=0; i<5; i++) {
375 for (let j=0; j<5; j++) {
376 if (this.board[i][j] != "" && this.getPiece(i, j) == 'p')
377 fmCount[this.getColor(i, j)]++;
378 }
379 }
380 if (Object.values(fmCount).some(v => v == 0)) {
381 if (fmCount['w'] == 0 && fmCount['b'] == 0)
382 // Everyone died
383 return "1/2";
384 if (fmCount['w'] == 0) return "0-1";
385 return "1-0"; //fmCount['b'] == 0
386 }
387 // Check penaltyFlags: if a side has 2 or more, it loses
388 if (Object.values(this.penalties).every(v => v == 2)) return "1/2";
389 if (this.penalties['w'] == 2) return "0-1";
390 if (this.penalties['b'] == 2) return "1-0";
391 if (!this.atLeastOneLegalMove('w') || !this.atLeastOneLegalMove('b'))
392 // Stalemate (should be very rare)
393 return "1/2";
394 return "*";
395 }
396
397 };