a92338f78dabf0def35087edf180a709002816bc
1 import { ChessRules
} from "@/base_rules";
2 import { ArrayFun
} from "@/utils/array";
4 // NOTE: alternative implementation, probably cleaner = use only 1 board
5 // TODO? atLeastOneMove() would be more efficient if rewritten here (less sideBoard computations)
6 export const VariantRules
= class AliceRules
extends ChessRules
{
7 static get ALICE_PIECES() {
17 static get ALICE_CODES() {
29 return ChessRules
.PIECES
.concat(Object
.keys(V
.ALICE_PIECES
));
33 return (Object
.keys(V
.ALICE_PIECES
).includes(b
[1]) ? "Alice/" : "") + b
;
36 setOtherVariables(fen
) {
37 super.setOtherVariables(fen
);
38 const rows
= V
.ParseFen(fen
).position
.split("/");
39 if (this.kingPos
["w"][0] < 0 || this.kingPos
["b"][0] < 0) {
40 // INIT_COL_XXX won't be required if Alice kings are found (means 'king moved')
41 for (let i
= 0; i
< rows
.length
; i
++) {
42 let k
= 0; //column index on board
43 for (let j
= 0; j
< rows
[i
].length
; j
++) {
44 switch (rows
[i
].charAt(j
)) {
46 this.kingPos
["b"] = [i
, k
];
49 this.kingPos
["w"] = [i
, k
];
52 const num
= parseInt(rows
[i
].charAt(j
));
53 if (!isNaN(num
)) k
+= num
- 1;
62 // Return the (standard) color+piece notation at a square for a board
63 getSquareOccupation(i
, j
, mirrorSide
) {
64 const piece
= this.getPiece(i
, j
);
65 if (mirrorSide
== 1 && Object
.keys(V
.ALICE_CODES
).includes(piece
))
66 return this.board
[i
][j
];
67 if (mirrorSide
== 2 && Object
.keys(V
.ALICE_PIECES
).includes(piece
))
68 return this.getColor(i
, j
) + V
.ALICE_PIECES
[piece
];
72 // Build board of the given (mirror)side
73 getSideBoard(mirrorSide
) {
74 // Build corresponding board from complete board
75 let sideBoard
= ArrayFun
.init(V
.size
.x
, V
.size
.y
, "");
76 for (let i
= 0; i
< V
.size
.x
; i
++) {
77 for (let j
= 0; j
< V
.size
.y
; j
++)
78 sideBoard
[i
][j
] = this.getSquareOccupation(i
, j
, mirrorSide
);
83 // NOTE: castle & enPassant https://www.chessvariants.com/other.dir/alice.html
84 getPotentialMovesFrom([x
, y
], sideBoard
) {
85 const pieces
= Object
.keys(V
.ALICE_CODES
);
86 const codes
= Object
.keys(V
.ALICE_PIECES
);
87 const mirrorSide
= pieces
.includes(this.getPiece(x
, y
)) ? 1 : 2;
88 if (!sideBoard
) sideBoard
= [this.getSideBoard(1), this.getSideBoard(2)];
89 const color
= this.getColor(x
, y
);
91 // Search valid moves on sideBoard
92 const saveBoard
= this.board
;
93 this.board
= sideBoard
[mirrorSide
- 1];
94 const moves
= super.getPotentialMovesFrom([x
, y
]).filter(m
=> {
95 // Filter out king moves which result in under-check position on
96 // current board (before mirror traversing)
97 let aprioriValid
= true;
98 if (m
.appear
[0].p
== V
.KING
) {
100 if (this.underCheck(color
, sideBoard
)) aprioriValid
= false;
105 this.board
= saveBoard
;
107 // Finally filter impossible moves
108 const res
= moves
.filter(m
=> {
109 if (m
.appear
.length
== 2) {
111 // appear[i] must be an empty square on the other board
112 for (let psq
of m
.appear
) {
113 if (this.getSquareOccupation(psq
.x
, psq
.y
, 3 - mirrorSide
) != V
.EMPTY
)
116 } else if (this.board
[m
.end
.x
][m
.end
.y
] != V
.EMPTY
) {
117 // Attempt to capture
118 const piece
= this.getPiece(m
.end
.x
, m
.end
.y
);
120 (mirrorSide
== 1 && codes
.includes(piece
)) ||
121 (mirrorSide
== 2 && pieces
.includes(piece
))
126 // If the move is computed on board1, m.appear change for Alice pieces.
127 if (mirrorSide
== 1) {
128 m
.appear
.forEach(psq
=> {
129 //forEach: castling taken into account
130 psq
.p
= V
.ALICE_CODES
[psq
.p
]; //goto board2
132 } //move on board2: mark vanishing pieces as Alice
134 m
.vanish
.forEach(psq
=> {
135 psq
.p
= V
.ALICE_CODES
[psq
.p
];
138 // Fix en-passant captures
140 m
.vanish
[0].p
== V
.PAWN
&&
141 m
.vanish
.length
== 2 &&
142 this.board
[m
.end
.x
][m
.end
.y
] == V
.EMPTY
144 m
.vanish
[1].c
= V
.GetOppCol(this.getColor(x
, y
));
145 // In the special case of en-passant, if
146 // - board1 takes board2 : vanish[1] --> Alice
147 // - board2 takes board1 : vanish[1] --> normal
148 let van
= m
.vanish
[1];
149 if (mirrorSide
== 1 && codes
.includes(this.getPiece(van
.x
, van
.y
)))
150 van
.p
= V
.ALICE_CODES
[van
.p
];
153 pieces
.includes(this.getPiece(van
.x
, van
.y
))
155 van
.p
= V
.ALICE_PIECES
[van
.p
];
162 filterValid(moves
, sideBoard
) {
163 if (moves
.length
== 0) return [];
164 if (!sideBoard
) sideBoard
= [this.getSideBoard(1), this.getSideBoard(2)];
165 const color
= this.turn
;
166 return moves
.filter(m
=> {
167 this.playSide(m
, sideBoard
); //no need to track flags
168 const res
= !this.underCheck(color
, sideBoard
);
169 this.undoSide(m
, sideBoard
);
175 const color
= this.turn
;
176 let potentialMoves
= [];
177 const sideBoard
= [this.getSideBoard(1), this.getSideBoard(2)];
178 for (var i
= 0; i
< V
.size
.x
; i
++) {
179 for (var j
= 0; j
< V
.size
.y
; j
++) {
180 if (this.board
[i
][j
] != V
.EMPTY
&& this.getColor(i
, j
) == color
) {
181 Array
.prototype.push
.apply(
183 this.getPotentialMovesFrom([i
, j
], sideBoard
)
188 return this.filterValid(potentialMoves
, sideBoard
);
191 // Play on sideboards [TODO: only one sideBoard required]
192 playSide(move, sideBoard
) {
193 const pieces
= Object
.keys(V
.ALICE_CODES
);
194 move.vanish
.forEach(psq
=> {
195 const mirrorSide
= pieces
.includes(psq
.p
) ? 1 : 2;
196 sideBoard
[mirrorSide
- 1][psq
.x
][psq
.y
] = V
.EMPTY
;
198 move.appear
.forEach(psq
=> {
199 const mirrorSide
= pieces
.includes(psq
.p
) ? 1 : 2;
200 const piece
= mirrorSide
== 1 ? psq
.p : V
.ALICE_PIECES
[psq
.p
];
201 sideBoard
[mirrorSide
- 1][psq
.x
][psq
.y
] = psq
.c
+ piece
;
202 if (piece
== V
.KING
) this.kingPos
[psq
.c
] = [psq
.x
, psq
.y
];
206 // Undo on sideboards
207 undoSide(move, sideBoard
) {
208 const pieces
= Object
.keys(V
.ALICE_CODES
);
209 move.appear
.forEach(psq
=> {
210 const mirrorSide
= pieces
.includes(psq
.p
) ? 1 : 2;
211 sideBoard
[mirrorSide
- 1][psq
.x
][psq
.y
] = V
.EMPTY
;
213 move.vanish
.forEach(psq
=> {
214 const mirrorSide
= pieces
.includes(psq
.p
) ? 1 : 2;
215 const piece
= mirrorSide
== 1 ? psq
.p : V
.ALICE_PIECES
[psq
.p
];
216 sideBoard
[mirrorSide
- 1][psq
.x
][psq
.y
] = psq
.c
+ piece
;
217 if (piece
== V
.KING
) this.kingPos
[psq
.c
] = [psq
.x
, psq
.y
];
221 // sideBoard: arg containing both boards (see getAllValidMoves())
222 underCheck(color
, sideBoard
) {
223 const kp
= this.kingPos
[color
];
224 const mirrorSide
= sideBoard
[0][kp
[0]][kp
[1]] != V
.EMPTY
? 1 : 2;
225 let saveBoard
= this.board
;
226 this.board
= sideBoard
[mirrorSide
- 1];
227 let res
= this.isAttacked(kp
, [V
.GetOppCol(color
)]);
228 this.board
= saveBoard
;
232 getCheckSquares(color
) {
233 const pieces
= Object
.keys(V
.ALICE_CODES
);
234 const kp
= this.kingPos
[color
];
235 const mirrorSide
= pieces
.includes(this.getPiece(kp
[0], kp
[1])) ? 1 : 2;
236 let sideBoard
= this.getSideBoard(mirrorSide
);
237 let saveBoard
= this.board
;
238 this.board
= sideBoard
;
239 let res
= this.isAttacked(this.kingPos
[color
], [V
.GetOppCol(color
)])
240 ? [JSON
.parse(JSON
.stringify(this.kingPos
[color
]))]
242 this.board
= saveBoard
;
246 updateVariables(move) {
247 super.updateVariables(move); //standard king
248 const piece
= move.vanish
[0].p
;
249 const c
= move.vanish
[0].c
;
252 this.kingPos
[c
][0] = move.appear
[0].x
;
253 this.kingPos
[c
][1] = move.appear
[0].y
;
254 this.castleFlags
[c
] = [false, false];
258 unupdateVariables(move) {
259 super.unupdateVariables(move);
260 const c
= move.vanish
[0].c
;
261 if (move.vanish
[0].p
== "l") this.kingPos
[c
] = [move.start
.x
, move.start
.y
];
265 if (this.atLeastOneMove())
269 const pieces
= Object
.keys(V
.ALICE_CODES
);
270 const color
= this.turn
;
271 const kp
= this.kingPos
[color
];
272 const mirrorSide
= pieces
.includes(this.getPiece(kp
[0], kp
[1])) ? 1 : 2;
273 let sideBoard
= this.getSideBoard(mirrorSide
);
274 let saveBoard
= this.board
;
275 this.board
= sideBoard
;
277 if (!this.isAttacked(this.kingPos
[color
], [V
.GetOppCol(color
)]))
279 else res
= color
== "w" ? "0-1" : "1-0";
280 this.board
= saveBoard
;
284 static get VALUES() {
285 return Object
.assign(ChessRules
.VALUES
, {
296 if (move.appear
.length
== 2 && move.appear
[0].p
== V
.KING
) {
297 if (move.end
.y
< move.start
.y
) return "0-0-0";
301 const finalSquare
= V
.CoordsToSquare(move.end
);
302 const piece
= this.getPiece(move.start
.x
, move.start
.y
);
304 const captureMark
= move.vanish
.length
> move.appear
.length
? "x" : "";
306 if (["p", "s"].includes(piece
) && captureMark
.length
== 1)
307 pawnMark
= V
.CoordToColumn(move.start
.y
); //start column
309 // Piece or pawn movement
310 let notation
= piece
.toUpperCase() + pawnMark
+ captureMark
+ finalSquare
;
311 if (["s", "p"].includes(piece
) && !["s", "p"].includes(move.appear
[0].p
)) {
313 notation
+= "=" + move.appear
[0].p
.toUpperCase();