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 outerLoop: for (let step
of steps
) {
83 let i
= V
.ComputeX(x
+ step
[0]);
85 while (V
.OnBoard(i
, j
) && this.board
[i
][j
] == V
.EMPTY
) {
86 moves
.push(this.getBasicMove([x
, y
], [i
, j
]));
87 if (oneStep
!== undefined) continue outerLoop
;
88 i
= V
.ComputeX(i
+ step
[0]);
91 if (V
.OnBoard(i
, j
) && this.canTake([x
, y
], [i
, j
]))
92 moves
.push(this.getBasicMove([x
, y
], [i
, j
]));
97 getPotentialPawnMoves([x
, y
]) {
98 const color
= this.turn
;
100 const [sizeX
, sizeY
] = [V
.size
.x
, V
.size
.y
];
101 // All pawns go in the same direction!
103 const startRank
= color
== "w" ? sizeX
- 2 : 2;
105 // One square forward
106 const nextRow
= V
.ComputeX(x
+ shiftX
);
107 if (this.board
[nextRow
][y
] == V
.EMPTY
) {
108 moves
.push(this.getBasicMove([x
, y
], [nextRow
, y
]));
111 this.pawnFlags
[color
][y
] &&
112 this.board
[x
+ 2 * shiftX
][y
] == V
.EMPTY
115 moves
.push(this.getBasicMove([x
, y
], [x
+ 2 * shiftX
, y
]));
119 for (let shiftY
of [-1, 1]) {
122 y
+ shiftY
< sizeY
&&
123 this.board
[nextRow
][y
+ shiftY
] != V
.EMPTY
&&
124 this.canTake([x
, y
], [nextRow
, y
+ shiftY
])
126 moves
.push(this.getBasicMove([x
, y
], [nextRow
, y
+ shiftY
]));
134 const filteredMoves
= super.filterValid(moves
);
135 // If at least one full move made, everything is allowed:
136 if (this.movesCount
>= 2) return filteredMoves
;
137 // Else, forbid check:
138 const oppCol
= V
.GetOppCol(this.turn
);
139 return filteredMoves
.filter(m
=> {
141 const res
= !this.underCheck(oppCol
);
147 isAttackedByPawn([x
, y
], color
) {
148 // pawn shift is always 1 (all pawns go the same way)
149 const attackerRow
= V
.ComputeX(x
+ 1);
150 for (let i
of [-1, 1]) {
154 this.getPiece(attackerRow
, y
+ i
) == V
.PAWN
&&
155 this.getColor(attackerRow
, y
+ i
) == color
163 isAttackedBySlideNJump([x
, y
], color
, piece
, steps
, oneStep
) {
164 for (let step
of steps
) {
165 let rx
= V
.ComputeX(x
+ step
[0]),
167 while (V
.OnBoard(rx
, ry
) && this.board
[rx
][ry
] == V
.EMPTY
&& !oneStep
) {
168 rx
= V
.ComputeX(rx
+ step
[0]);
173 this.getPiece(rx
, ry
) == piece
&&
174 this.getColor(rx
, ry
) == color
183 // Return pawns flags
185 for (let c
of ["w", "b"]) {
186 for (let i
= 0; i
< 8; i
++) flags
+= this.pawnFlags
[c
][i
] ? "1" : "0";
192 super.postPlay(move);
193 const c
= move.vanish
[0].c
;
194 const secondRank
= { "w": 6, "b": 2 };
195 if (move.vanish
[0].p
== V
.PAWN
&& secondRank
[c
] == move.start
.x
)
196 // This move turns off a 2-squares pawn flag
197 this.pawnFlags
[c
][move.start
.y
] = false;
200 static get VALUES() {
211 static get SEARCH_DEPTH() {