1 import { ChessRules
, PiPo
, Move
} from "@/base_rules";
2 import { ArrayFun
} from "@/utils/array";
3 import { shuffle
} from "@/utils/alea";
5 export class CircularRules
extends ChessRules
{
6 static get HasCastle() {
10 static get HasEnpassant() {
14 static get CanFlip() {
20 w: [...Array(8).fill(true)], //pawns can move 2 squares?
21 b: [...Array(8).fill(true)]
23 for (let c
of ["w", "b"]) {
24 for (let i
= 0; i
< 8; i
++)
25 this.pawnFlags
[c
][i
] = fenflags
.charAt((c
== "w" ? 0 : 8) + i
) == "1";
30 return this.pawnFlags
;
33 disaggregateFlags(flags
) {
34 this.pawnFlags
= flags
;
37 static GenRandInitFen(randomness
) {
39 return "8/8/pppppppp/rnbqkbnr/8/8/PPPPPPPP/RNBQKBNR w 0 1111111111111111";
41 let pieces
= { w: new Array(8), b: new Array(8) };
42 // Shuffle pieces on first and last rank
43 for (let c
of ["w", "b"]) {
44 if (c
== 'b' && randomness
== 1) {
45 pieces
['b'] = pieces
['w'];
49 // Get random squares for every piece, totally freely
50 let positions
= shuffle(ArrayFun
.range(8));
51 const composition
= ['b', 'b', 'r', 'r', 'n', 'n', 'k', 'q'];
52 const rem2
= positions
[0] % 2;
53 if (rem2
== positions
[1] % 2) {
54 // Fix bishops (on different colors)
55 for (let i
=2; i
<8; i
++) {
56 if (positions
[i
] % 2 != rem2
)
57 [positions
[1], positions
[i
]] = [positions
[i
], positions
[1]];
60 for (let i
= 0; i
< 8; i
++) pieces
[c
][positions
[i
]] = composition
[i
];
64 pieces
["b"].join("") +
66 pieces
["w"].join("").toUpperCase() +
67 // 16 flags: can pawns advance 2 squares?
68 " w 0 1111111111111111"
72 // Output basically x % 8 (circular board)
74 let res
= x
% V
.size
.x
;
80 getSlideNJumpMoves([x
, y
], steps
, oneStep
) {
82 // Don't add move twice when running on an infinite file:
83 let infiniteSteps
= {};
84 outerLoop: for (let step
of steps
) {
85 if (!!infiniteSteps
[(-step
[0]) + "." + (-step
[1])]) continue;
86 let i
= V
.ComputeX(x
+ step
[0]);
88 while (V
.OnBoard(i
, j
) && this.board
[i
][j
] == V
.EMPTY
) {
89 moves
.push(this.getBasicMove([x
, y
], [i
, j
]));
90 if (oneStep
!== undefined) continue outerLoop
;
91 i
= V
.ComputeX(i
+ step
[0]);
94 if (V
.OnBoard(i
, j
)) {
96 // Looped back onto initial square
97 infiniteSteps
[step
[0] + "." + step
[1]] = true;
98 else if (this.canTake([x
, y
], [i
, j
]))
99 moves
.push(this.getBasicMove([x
, y
], [i
, j
]));
105 getPotentialPawnMoves([x
, y
]) {
106 const color
= this.turn
;
108 const [sizeX
, sizeY
] = [V
.size
.x
, V
.size
.y
];
109 // All pawns go in the same direction!
111 const startRank
= color
== "w" ? sizeX
- 2 : 2;
113 // One square forward
114 const nextRow
= V
.ComputeX(x
+ shiftX
);
115 if (this.board
[nextRow
][y
] == V
.EMPTY
) {
116 moves
.push(this.getBasicMove([x
, y
], [nextRow
, y
]));
119 this.pawnFlags
[color
][y
] &&
120 this.board
[x
+ 2 * shiftX
][y
] == V
.EMPTY
123 moves
.push(this.getBasicMove([x
, y
], [x
+ 2 * shiftX
, y
]));
127 for (let shiftY
of [-1, 1]) {
130 y
+ shiftY
< sizeY
&&
131 this.board
[nextRow
][y
+ shiftY
] != V
.EMPTY
&&
132 this.canTake([x
, y
], [nextRow
, y
+ shiftY
])
134 moves
.push(this.getBasicMove([x
, y
], [nextRow
, y
+ shiftY
]));
142 const filteredMoves
= super.filterValid(moves
);
143 // If at least one full move made, everything is allowed:
144 if (this.movesCount
>= 2) return filteredMoves
;
145 // Else, forbid check:
146 const oppCol
= V
.GetOppCol(this.turn
);
147 return filteredMoves
.filter(m
=> {
149 const res
= !this.underCheck(oppCol
);
155 isAttackedByPawn([x
, y
], color
) {
156 // pawn shift is always 1 (all pawns go the same way)
157 const attackerRow
= V
.ComputeX(x
+ 1);
158 for (let i
of [-1, 1]) {
162 this.getPiece(attackerRow
, y
+ i
) == V
.PAWN
&&
163 this.getColor(attackerRow
, y
+ i
) == color
171 isAttackedBySlideNJump([x
, y
], color
, piece
, steps
, oneStep
) {
172 for (let step
of steps
) {
173 let rx
= V
.ComputeX(x
+ step
[0]),
175 while (V
.OnBoard(rx
, ry
) && this.board
[rx
][ry
] == V
.EMPTY
&& !oneStep
) {
176 rx
= V
.ComputeX(rx
+ step
[0]);
181 this.getPiece(rx
, ry
) == piece
&&
182 this.getColor(rx
, ry
) == color
191 // Return pawns flags
193 for (let c
of ["w", "b"]) {
194 for (let i
= 0; i
< 8; i
++) flags
+= this.pawnFlags
[c
][i
] ? "1" : "0";
200 super.postPlay(move);
201 const c
= move.vanish
[0].c
;
202 const secondRank
= { "w": 6, "b": 2 };
203 if (move.vanish
[0].p
== V
.PAWN
&& secondRank
[c
] == move.start
.x
)
204 // This move turns off a 2-squares pawn flag
205 this.pawnFlags
[c
][move.start
.y
] = false;
208 static get VALUES() {
219 static get SEARCH_DEPTH() {