1 import { ChessRules
} from "@/base_rules";
2 import { ArrayFun
} from "@/utils/array";
3 import { randInt
} from "@/utils/alea";
5 // NOTE: initial setup differs from the original; see
6 // https://www.chessvariants.com/large.dir/freeling.html
7 export const VariantRules
= class GrandRules
extends ChessRules
{
8 static IsGoodFen(fen
) {
9 if (!ChessRules
.IsGoodFen(fen
)) return false;
10 const fenParsed
= V
.ParseFen(fen
);
12 if (!fenParsed
.captured
|| !fenParsed
.captured
.match(/^[0-9]{14,14}$/))
17 static IsGoodEnpassant(enpassant
) {
18 if (enpassant
!= "-") {
19 const squares
= enpassant
.split(",");
20 if (squares
.length
> 2) return false;
21 for (let sq
of squares
) {
22 const ep
= V
.SquareToCoords(sq
);
23 if (isNaN(ep
.x
) || !V
.OnBoard(ep
)) return false;
29 static ParseFen(fen
) {
30 const fenParts
= fen
.split(" ");
31 return Object
.assign(ChessRules
.ParseFen(fen
), { captured: fenParts
[5] });
35 return ([V
.MARSHALL
, V
.CARDINAL
].includes(b
[1]) ? "Grand/" : "") + b
;
39 return super.getFen() + " " + this.getCapturedFen();
43 return super.getFenForRepeat() + "_" + this.getCapturedFen();
47 let counts
= [...Array(14).fill(0)];
49 for (let j
= 0; j
< V
.PIECES
.length
; j
++) {
50 if (V
.PIECES
[j
] == V
.KING
)
53 counts
[i
] = this.captured
["w"][V
.PIECES
[i
]];
54 counts
[7 + i
] = this.captured
["b"][V
.PIECES
[i
]];
57 return counts
.join("");
60 setOtherVariables(fen
) {
61 super.setOtherVariables(fen
);
62 const fenParsed
= V
.ParseFen(fen
);
63 // Initialize captured pieces' counts from FEN
66 [V
.PAWN
]: parseInt(fenParsed
.captured
[0]),
67 [V
.ROOK
]: parseInt(fenParsed
.captured
[1]),
68 [V
.KNIGHT
]: parseInt(fenParsed
.captured
[2]),
69 [V
.BISHOP
]: parseInt(fenParsed
.captured
[3]),
70 [V
.QUEEN
]: parseInt(fenParsed
.captured
[4]),
71 [V
.MARSHALL
]: parseInt(fenParsed
.captured
[5]),
72 [V
.CARDINAL
]: parseInt(fenParsed
.captured
[6])
75 [V
.PAWN
]: parseInt(fenParsed
.captured
[7]),
76 [V
.ROOK
]: parseInt(fenParsed
.captured
[8]),
77 [V
.KNIGHT
]: parseInt(fenParsed
.captured
[9]),
78 [V
.BISHOP
]: parseInt(fenParsed
.captured
[10]),
79 [V
.QUEEN
]: parseInt(fenParsed
.captured
[11]),
80 [V
.MARSHALL
]: parseInt(fenParsed
.captured
[12]),
81 [V
.CARDINAL
]: parseInt(fenParsed
.captured
[13])
87 return { x: 10, y: 10 };
90 static get MARSHALL() {
93 static get CARDINAL() {
98 return ChessRules
.PIECES
.concat([V
.MARSHALL
, V
.CARDINAL
]);
101 // There may be 2 enPassant squares (if pawn jump 3 squares)
103 const L
= this.epSquares
.length
;
104 if (!this.epSquares
[L
- 1]) return "-"; //no en-passant
106 this.epSquares
[L
- 1].forEach(sq
=> {
107 res
+= V
.CoordsToSquare(sq
) + ",";
109 return res
.slice(0, -1); //remove last comma
112 // En-passant after 2-sq or 3-sq jumps
113 getEpSquare(moveOrSquare
) {
114 if (!moveOrSquare
) return undefined;
115 if (typeof moveOrSquare
=== "string") {
116 const square
= moveOrSquare
;
117 if (square
== "-") return undefined;
119 square
.split(",").forEach(sq
=> {
120 res
.push(V
.SquareToCoords(sq
));
124 // Argument is a move:
125 const move = moveOrSquare
;
126 const [sx
, sy
, ex
] = [move.start
.x
, move.start
.y
, move.end
.x
];
127 if (this.getPiece(sx
, sy
) == V
.PAWN
&& Math
.abs(sx
- ex
) >= 2) {
128 const step
= (ex
- sx
) / Math
.abs(ex
- sx
);
135 if (sx
+ 2 * step
!= ex
) {
144 return undefined; //default
147 getPotentialMovesFrom([x
, y
]) {
148 switch (this.getPiece(x
, y
)) {
150 return this.getPotentialMarshallMoves([x
, y
]);
152 return this.getPotentialCardinalMoves([x
, y
]);
154 return super.getPotentialMovesFrom([x
, y
]);
158 // Special pawn rules: promotions to captured friendly pieces,
159 // optional on ranks 8-9 and mandatory on rank 10.
160 getPotentialPawnMoves([x
, y
]) {
161 const color
= this.turn
;
163 const [sizeX
, sizeY
] = [V
.size
.x
, V
.size
.y
];
164 const shiftX
= color
== "w" ? -1 : 1;
165 const startRanks
= color
== "w" ? [sizeX
- 2, sizeX
- 3] : [1, 2];
167 color
== "w" ? [0, 1, 2] : [sizeX
- 1, sizeX
- 2, sizeX
- 3];
168 const promotionPieces
= [
177 // Always x+shiftX >= 0 && x+shiftX < sizeX, because no pawns on last rank
178 let finalPieces
= undefined;
179 if (lastRanks
.includes(x
+ shiftX
)) {
180 finalPieces
= promotionPieces
.filter(p
=> this.captured
[color
][p
] > 0);
181 if (x
+ shiftX
!= lastRanks
[0]) finalPieces
.push(V
.PAWN
);
182 } else finalPieces
= [V
.PAWN
];
183 if (this.board
[x
+ shiftX
][y
] == V
.EMPTY
) {
184 // One square forward
185 for (let piece
of finalPieces
)
187 this.getBasicMove([x
, y
], [x
+ shiftX
, y
], { c: color
, p: piece
})
189 if (startRanks
.includes(x
)) {
190 if (this.board
[x
+ 2 * shiftX
][y
] == V
.EMPTY
) {
192 moves
.push(this.getBasicMove([x
, y
], [x
+ 2 * shiftX
, y
]));
193 if (x
== startRanks
[0] && this.board
[x
+ 3 * shiftX
][y
] == V
.EMPTY
) {
194 // Three squares jump
195 moves
.push(this.getBasicMove([x
, y
], [x
+ 3 * shiftX
, y
]));
201 for (let shiftY
of [-1, 1]) {
204 y
+ shiftY
< sizeY
&&
205 this.board
[x
+ shiftX
][y
+ shiftY
] != V
.EMPTY
&&
206 this.canTake([x
, y
], [x
+ shiftX
, y
+ shiftY
])
208 for (let piece
of finalPieces
) {
210 this.getBasicMove([x
, y
], [x
+ shiftX
, y
+ shiftY
], {
220 const Lep
= this.epSquares
.length
;
221 const epSquare
= this.epSquares
[Lep
- 1];
223 for (let epsq
of epSquare
) {
224 // TODO: some redundant checks
225 if (epsq
.x
== x
+ shiftX
&& Math
.abs(epsq
.y
- y
) == 1) {
226 var enpassantMove
= this.getBasicMove([x
, y
], [epsq
.x
, epsq
.y
]);
227 // WARNING: the captured pawn may be diagonally behind us,
228 // if it's a 3-squares jump and we take on 1st passing square
229 const px
= this.board
[x
][epsq
.y
] != V
.EMPTY
? x : x
- shiftX
;
230 enpassantMove
.vanish
.push({
234 c: this.getColor(px
, epsq
.y
)
236 moves
.push(enpassantMove
);
244 // TODO: different castle?
246 getPotentialMarshallMoves(sq
) {
247 return this.getSlideNJumpMoves(sq
, V
.steps
[V
.ROOK
]).concat(
248 this.getSlideNJumpMoves(sq
, V
.steps
[V
.KNIGHT
], "oneStep")
252 getPotentialCardinalMoves(sq
) {
253 return this.getSlideNJumpMoves(sq
, V
.steps
[V
.BISHOP
]).concat(
254 this.getSlideNJumpMoves(sq
, V
.steps
[V
.KNIGHT
], "oneStep")
258 isAttacked(sq
, colors
) {
260 super.isAttacked(sq
, colors
) ||
261 this.isAttackedByMarshall(sq
, colors
) ||
262 this.isAttackedByCardinal(sq
, colors
)
266 isAttackedByMarshall(sq
, colors
) {
268 this.isAttackedBySlideNJump(sq
, colors
, V
.MARSHALL
, V
.steps
[V
.ROOK
]) ||
269 this.isAttackedBySlideNJump(
279 isAttackedByCardinal(sq
, colors
) {
281 this.isAttackedBySlideNJump(sq
, colors
, V
.CARDINAL
, V
.steps
[V
.BISHOP
]) ||
282 this.isAttackedBySlideNJump(
292 updateVariables(move) {
293 super.updateVariables(move);
294 if (move.vanish
.length
== 2 && move.appear
.length
== 1) {
295 // Capture: update this.captured
296 this.captured
[move.vanish
[1].c
][move.vanish
[1].p
]++;
298 if (move.vanish
[0].p
!= move.appear
[0].p
) {
299 // Promotion: update this.captured
300 this.captured
[move.vanish
[0].c
][move.appear
[0].p
]--;
304 unupdateVariables(move) {
305 super.unupdateVariables(move);
306 if (move.vanish
.length
== 2 && move.appear
.length
== 1)
307 this.captured
[move.vanish
[1].c
][move.vanish
[1].p
]--;
308 if (move.vanish
[0].p
!= move.appear
[0].p
)
309 this.captured
[move.vanish
[0].c
][move.appear
[0].p
]++;
312 static get VALUES() {
313 return Object
.assign(
314 { c: 5, m: 7 }, //experimental
319 static get SEARCH_DEPTH() {
323 static GenRandInitFen(randomness
) {
324 if (randomness
== 0) {
325 // No castling in the official initial setup
326 return "r8r/1nbqkmcbn1/pppppppppp/10/10/10/10/PPPPPPPPPP/1NBQKMCBN1/R8R " +
327 "w 0 0000 - 00000000000000";
330 let pieces
= { w: new Array(10), b: new Array(10) };
331 // Shuffle pieces on first and last rank
332 for (let c
of ["w", "b"]) {
333 if (c
== 'b' && randomness
== 1) {
334 pieces
['b'] = pieces
['w'];
338 let positions
= ArrayFun
.range(10);
340 // Get random squares for bishops
341 let randIndex
= 2 * randInt(5);
342 let bishop1Pos
= positions
[randIndex
];
343 // The second bishop must be on a square of different color
344 let randIndex_tmp
= 2 * randInt(5) + 1;
345 let bishop2Pos
= positions
[randIndex_tmp
];
346 // Remove chosen squares
347 positions
.splice(Math
.max(randIndex
, randIndex_tmp
), 1);
348 positions
.splice(Math
.min(randIndex
, randIndex_tmp
), 1);
350 // Get random squares for knights
351 randIndex
= randInt(8);
352 let knight1Pos
= positions
[randIndex
];
353 positions
.splice(randIndex
, 1);
354 randIndex
= randInt(7);
355 let knight2Pos
= positions
[randIndex
];
356 positions
.splice(randIndex
, 1);
358 // Get random square for queen
359 randIndex
= randInt(6);
360 let queenPos
= positions
[randIndex
];
361 positions
.splice(randIndex
, 1);
363 // ...random square for marshall
364 randIndex
= randInt(5);
365 let marshallPos
= positions
[randIndex
];
366 positions
.splice(randIndex
, 1);
368 // ...random square for cardinal
369 randIndex
= randInt(4);
370 let cardinalPos
= positions
[randIndex
];
371 positions
.splice(randIndex
, 1);
373 // Rooks and king positions are now fixed, because of the ordering rook-king-rook
374 let rook1Pos
= positions
[0];
375 let kingPos
= positions
[1];
376 let rook2Pos
= positions
[2];
378 // Finally put the shuffled pieces in the board array
379 pieces
[c
][rook1Pos
] = "r";
380 pieces
[c
][knight1Pos
] = "n";
381 pieces
[c
][bishop1Pos
] = "b";
382 pieces
[c
][queenPos
] = "q";
383 pieces
[c
][marshallPos
] = "m";
384 pieces
[c
][cardinalPos
] = "c";
385 pieces
[c
][kingPos
] = "k";
386 pieces
[c
][bishop2Pos
] = "b";
387 pieces
[c
][knight2Pos
] = "n";
388 pieces
[c
][rook2Pos
] = "r";
391 pieces
["b"].join("") +
392 "/pppppppppp/10/10/10/10/10/10/PPPPPPPPPP/" +
393 pieces
["w"].join("").toUpperCase() +
394 " w 0 1111 - 00000000000000"