Debug Knightrelay variant
[vchess.git] / client / src / variants / Circular.js
1 import { ChessRules, PiPo, Move } from "@/base_rules";
2 import { ArrayFun } from "@/utils/array";
3 import { randInt, shuffle } from "@/utils/alea";
4
5 export const VariantRules = class CircularRules extends ChessRules {
6 static get HasEnpassant() {
7 return false;
8 }
9
10 static get CanFlip() {
11 return false;
12 }
13
14 setFlags(fenflags) {
15 this.pawnFlags = {
16 w: [...Array(8).fill(true)], //pawns can move 2 squares?
17 b: [...Array(8).fill(true)]
18 };
19 for (let c of ["w", "b"]) {
20 for (let i = 0; i < 8; i++)
21 this.pawnFlags[c][i] = fenflags.charAt((c == "w" ? 0 : 8) + i) == "1";
22 }
23 }
24
25 aggregateFlags() {
26 return this.pawnFlags;
27 }
28
29 disaggregateFlags(flags) {
30 this.pawnFlags = flags;
31 }
32
33 static GenRandInitFen() {
34 let pieces = { w: new Array(8), b: new Array(8) };
35 // Shuffle pieces on first and fifth rank
36 for (let c of ["w", "b"]) {
37 let positions = ArrayFun.range(8);
38
39 // Get random squares for bishops
40 let randIndex = 2 * randInt(4);
41 const bishop1Pos = positions[randIndex];
42 // The second bishop must be on a square of different color
43 let randIndex_tmp = 2 * randInt(4) + 1;
44 const bishop2Pos = positions[randIndex_tmp];
45 // Remove chosen squares
46 positions.splice(Math.max(randIndex, randIndex_tmp), 1);
47 positions.splice(Math.min(randIndex, randIndex_tmp), 1);
48
49 // Get random squares for knights
50 randIndex = randInt(6);
51 const knight1Pos = positions[randIndex];
52 positions.splice(randIndex, 1);
53 randIndex = randInt(5);
54 const knight2Pos = positions[randIndex];
55 positions.splice(randIndex, 1);
56
57 // Get random square for queen
58 randIndex = randInt(4);
59 const queenPos = positions[randIndex];
60 positions.splice(randIndex, 1);
61
62 // Rooks and king positions are now fixed,
63 // because of the ordering rook-king-rook
64 const rook1Pos = positions[0];
65 const kingPos = positions[1];
66 const rook2Pos = positions[2];
67
68 // Finally put the shuffled pieces in the board array
69 pieces[c][rook1Pos] = "r";
70 pieces[c][knight1Pos] = "n";
71 pieces[c][bishop1Pos] = "b";
72 pieces[c][queenPos] = "q";
73 pieces[c][kingPos] = "k";
74 pieces[c][bishop2Pos] = "b";
75 pieces[c][knight2Pos] = "n";
76 pieces[c][rook2Pos] = "r";
77 }
78 return (
79 "8/8/pppppppp/" +
80 pieces["b"].join("") +
81 "/8/8/PPPPPPPP/" +
82 pieces["w"].join("").toUpperCase() +
83 // 16 flags: can pawns advance 2 squares?
84 " w 0 1111111111111111"
85 );
86 }
87
88 // Output basically x % 8 (circular board)
89 static ComputeX(x) {
90 let res = x % V.size.x;
91 if (res < 0)
92 res += V.size.x;
93 return res;
94 }
95
96 getSlideNJumpMoves([x, y], steps, oneStep) {
97 let moves = [];
98 outerLoop: for (let step of steps) {
99 let i = V.ComputeX(x + step[0]);
100 let j = y + step[1];
101 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
102 moves.push(this.getBasicMove([x, y], [i, j]));
103 if (oneStep !== undefined) continue outerLoop;
104 i = V.ComputeX(i + step[0]);
105 j += step[1];
106 }
107 if (V.OnBoard(i, j) && this.canTake([x, y], [i, j]))
108 moves.push(this.getBasicMove([x, y], [i, j]));
109 }
110 return moves;
111 }
112
113 getPotentialPawnMoves([x, y]) {
114 const color = this.turn;
115 let moves = [];
116 const [sizeX, sizeY] = [V.size.x, V.size.y];
117 // All pawns go in the same direction!
118 const shiftX = -1;
119 const startRank = color == "w" ? sizeX - 2 : 2;
120
121 // One square forward
122 const nextRow = V.ComputeX(x + shiftX);
123 if (this.board[nextRow][y] == V.EMPTY) {
124 moves.push(this.getBasicMove([x, y], [nextRow, y]));
125 if (
126 x == startRank &&
127 this.pawnFlags[color][y] &&
128 this.board[x + 2 * shiftX][y] == V.EMPTY
129 ) {
130 // Two squares jump
131 moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
132 }
133 }
134 // Captures
135 for (let shiftY of [-1, 1]) {
136 if (
137 y + shiftY >= 0 &&
138 y + shiftY < sizeY &&
139 this.board[nextRow][y + shiftY] != V.EMPTY &&
140 this.canTake([x, y], [nextRow, y + shiftY])
141 ) {
142 moves.push(this.getBasicMove([x, y], [nextRow, y + shiftY]));
143 }
144 }
145
146 return moves;
147 }
148
149 getPotentialKingMoves(sq) {
150 return this.getSlideNJumpMoves(
151 sq,
152 V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
153 "oneStep"
154 );
155 }
156
157 filterValid(moves) {
158 const filteredMoves = super.filterValid(moves);
159 // If at least one full move made, everything is allowed:
160 if (this.movesCount >= 2)
161 return filteredMoves;
162 // Else, forbid check:
163 const oppCol = V.GetOppCol(this.turn);
164 return filteredMoves.filter(m => {
165 this.play(m);
166 const res = !this.underCheck(oppCol);
167 this.undo(m);
168 return res;
169 });
170 }
171
172 isAttackedByPawn([x, y], colors) {
173 const pawnShift = 1;
174 const attackerRow = V.ComputeX(x + pawnShift);
175 for (let c of colors) {
176 for (let i of [-1, 1]) {
177 if (
178 y + i >= 0 &&
179 y + i < V.size.y &&
180 this.getPiece(attackerRow, y + i) == V.PAWN &&
181 this.getColor(attackerRow, y + i) == c
182 ) {
183 return true;
184 }
185 }
186 }
187 return false;
188 }
189
190 isAttackedBySlideNJump([x, y], colors, piece, steps, oneStep) {
191 for (let step of steps) {
192 let rx = V.ComputeX(x + step[0]),
193 ry = y + step[1];
194 while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) {
195 rx = V.ComputeX(rx + step[0]);
196 ry += step[1];
197 }
198 if (
199 V.OnBoard(rx, ry) &&
200 this.getPiece(rx, ry) === piece &&
201 colors.includes(this.getColor(rx, ry))
202 ) {
203 return true;
204 }
205 }
206 return false;
207 }
208
209 getFlagsFen() {
210 // Return pawns flags
211 let flags = "";
212 for (let c of ["w", "b"]) {
213 for (let i = 0; i < 8; i++) flags += this.pawnFlags[c][i] ? "1" : "0";
214 }
215 return flags;
216 }
217
218 updateVariables(move) {
219 const c = move.vanish[0].c;
220 const secondRank = {"w":6, "b":2};
221 // Update king position + flags
222 if (move.vanish[0].p == V.KING && move.appear.length > 0) {
223 this.kingPos[c][0] = move.appear[0].x;
224 this.kingPos[c][1] = move.appear[0].y;
225 }
226 else if (move.vanish[0].p == V.PAWN && secondRank[c] == move.start.x)
227 // This move turns off a 2-squares pawn flag
228 this.pawnFlags[c][move.start.y] = false;
229 }
230
231 static get VALUES() {
232 return {
233 p: 1,
234 r: 5,
235 n: 3,
236 b: 4,
237 q: 10,
238 k: 1000
239 };
240 }
241 };