Attempt to improve scrolling on smartphone
[vchess.git] / client / src / variants / Coregal.js
1 import { ChessRules, Move, PiPo } from "@/base_rules";
2 import { ArrayFun } from "@/utils/array";
3 import { randInt, sample } from "@/utils/alea";
4
5 export class CoregalRules extends ChessRules {
6
7 static IsGoodPosition(position) {
8 if (!ChessRules.IsGoodPosition(position)) return false;
9 const rows = position.split("/");
10 // Check that at least one queen of each color is there:
11 let queens = {};
12 for (let row of rows) {
13 for (let i = 0; i < row.length; i++)
14 if (['Q','q'].includes(row[i])) queens[row[i]] = true;
15 }
16 if (Object.keys(queens).length != 2) return false;
17 return true;
18 }
19
20 static IsGoodFlags(flags) {
21 return !!flags.match(/^[a-z]{8,8}$/);
22 }
23
24 // Scanning king position for faster updates is still interesting.
25 scanKings(fen) {
26 this.kingPos = { w: [-1, -1], b: [-1, -1] };
27 const fenRows = V.ParseFen(fen).position.split("/");
28 const startRow = { 'w': V.size.x - 1, 'b': 0 };
29 for (let i = 0; i < fenRows.length; i++) {
30 let k = 0;
31 for (let j = 0; j < fenRows[i].length; j++) {
32 switch (fenRows[i].charAt(j)) {
33 case "k":
34 this.kingPos["b"] = [i, k];
35 break;
36 case "K":
37 this.kingPos["w"] = [i, k];
38 break;
39 default: {
40 const num = parseInt(fenRows[i].charAt(j), 10);
41 if (!isNaN(num)) k += num - 1;
42 }
43 }
44 k++;
45 }
46 }
47 }
48
49 getPPpath(m) {
50 if (
51 m.vanish.length == 2 &&
52 m.appear.length == 2 &&
53 m.vanish[0].p == V.QUEEN
54 ) {
55 // Large castle: show castle symbol
56 return "Coregal/castle";
57 }
58 return super.getPPpath(m);
59 }
60
61 getCheckSquares() {
62 const color = this.turn;
63 let squares = [];
64 const oppCol = V.GetOppCol(color);
65 if (this.isAttacked(this.kingPos[color], oppCol))
66 squares.push(JSON.parse(JSON.stringify(this.kingPos[color])));
67 for (let i=0; i<V.size.x; i++) {
68 for (let j=0; j<V.size.y; j++) {
69 if (
70 this.getColor(i, j) == color &&
71 this.getPiece(i, j) == V.QUEEN &&
72 this.isAttacked([i, j], oppCol)
73 ) {
74 squares.push([i, j]);
75 }
76 }
77 }
78 return squares;
79 }
80
81 static GenRandInitFen(options) {
82 if (options.randomness == 0)
83 // Castle flags here indicate pieces positions (if can castle)
84 return "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0 adehadeh -";
85
86 let pieces = { w: new Array(8), b: new Array(8) };
87 let flags = "";
88 for (let c of ["w", "b"]) {
89 if (c == 'b' && options.randomness == 1) {
90 pieces['b'] = pieces['w'];
91 flags += flags;
92 break;
93 }
94
95 // Get random squares for king and queen between b and g files
96 let randIndex = randInt(6) + 1;
97 let kingPos = randIndex;
98 randIndex = randInt(5) + 1;
99 if (randIndex >= kingPos) randIndex++;
100 let queenPos = randIndex;
101
102 // Get random squares for rooks to the left and right of the queen
103 // and king: not all squares of the same colors (for bishops).
104 const minQR = Math.min(kingPos, queenPos);
105 const maxQR = Math.max(kingPos, queenPos);
106 let rook1Pos = randInt(minQR);
107 let rook2Pos = 7 - randInt(7 - maxQR);
108
109 // Now, if we are unlucky all these 4 pieces may be on the same color.
110 const rem2 = [kingPos, queenPos, rook1Pos, rook2Pos].map(pos => pos % 2);
111 if (rem2.every(r => r == 0) || rem2.every(r => r == 1)) {
112 // Shift a random of these pieces to the left or right
113 switch (randInt(4)) {
114 case 0:
115 if (rook1Pos == 0) rook1Pos++;
116 else rook1Pos--;
117 break;
118 case 1:
119 if (Math.random() < 0.5) kingPos++;
120 else kingPos--;
121 break;
122 case 2:
123 if (Math.random() < 0.5) queenPos++;
124 else queenPos--;
125 break;
126 case 3:
127 if (rook2Pos == 7) rook2Pos--;
128 else rook2Pos++;
129 break;
130 }
131 }
132 let bishop1Options = { 0: true, 2: true, 4: true, 6: true };
133 let bishop2Options = { 1: true, 3: true, 5: true, 7: true };
134 [kingPos, queenPos, rook1Pos, rook2Pos].forEach(pos => {
135 if (!!bishop1Options[pos]) delete bishop1Options[pos];
136 else if (!!bishop2Options[pos]) delete bishop2Options[pos];
137 });
138 const bishop1Pos =
139 parseInt(sample(Object.keys(bishop1Options), 1)[0], 10);
140 const bishop2Pos =
141 parseInt(sample(Object.keys(bishop2Options), 1)[0], 10);
142
143 // Knights' positions are now determined
144 const forbidden = [
145 kingPos, queenPos, rook1Pos, rook2Pos, bishop1Pos, bishop2Pos
146 ];
147 const [knight1Pos, knight2Pos] =
148 ArrayFun.range(8).filter(pos => !forbidden.includes(pos));
149
150 pieces[c][rook1Pos] = "r";
151 pieces[c][knight1Pos] = "n";
152 pieces[c][bishop1Pos] = "b";
153 pieces[c][queenPos] = "q";
154 pieces[c][kingPos] = "k";
155 pieces[c][bishop2Pos] = "b";
156 pieces[c][knight2Pos] = "n";
157 pieces[c][rook2Pos] = "r";
158 flags += [rook1Pos, queenPos, kingPos, rook2Pos]
159 .sort().map(V.CoordToColumn).join("");
160 }
161 // Add turn + flags + enpassant
162 return (
163 pieces["b"].join("") +
164 "/pppppppp/8/8/8/8/PPPPPPPP/" +
165 pieces["w"].join("").toUpperCase() +
166 " w 0 " + flags + " -"
167 );
168 }
169
170 setFlags(fenflags) {
171 // white pieces positions, then black pieces positions
172 this.castleFlags = { w: [...Array(4)], b: [...Array(4)] };
173 for (let i = 0; i < 8; i++) {
174 this.castleFlags[i < 4 ? "w" : "b"][i % 4] =
175 V.ColumnToCoord(fenflags.charAt(i))
176 }
177 }
178
179 getPotentialQueenMoves([x, y]) {
180 let moves = super.getPotentialQueenMoves([x, y]);
181 const c = this.getColor(x, y);
182 if (this.castleFlags[c].slice(1, 3).includes(y))
183 moves = moves.concat(this.getCastleMoves([x, y]));
184 return moves;
185 }
186
187 getPotentialKingMoves([x, y]) {
188 let moves = this.getSlideNJumpMoves(
189 [x, y], V.steps[V.ROOK].concat(V.steps[V.BISHOP]), 1);
190 const c = this.getColor(x, y);
191 if (this.castleFlags[c].slice(1, 3).includes(y))
192 moves = moves.concat(this.getCastleMoves([x, y]));
193 return moves;
194 }
195
196 getCastleMoves([x, y]) {
197 // Relative position of the selected piece: left or right ?
198 // If left: small castle left, large castle right.
199 // If right: usual situation.
200 const c = this.getColor(x, y);
201 const relPos = (this.castleFlags[c][1] == y ? "left" : "right");
202
203 const finalSquares = [
204 relPos == "left" ? [1, 2] : [2, 3],
205 relPos == "right" ? [6, 5] : [5, 4]
206 ];
207 const saveFlags = JSON.stringify(this.castleFlags[c]);
208 // Alter flags to follow base_rules semantic
209 this.castleFlags[c] = [0, 3].map(i => this.castleFlags[c][i]);
210 const moves = super.getCastleMoves([x, y], finalSquares);
211 this.castleFlags[c] = JSON.parse(saveFlags);
212 return moves;
213 }
214
215 underCheck(color) {
216 const oppCol = V.GetOppCol(color);
217 if (this.isAttacked(this.kingPos[color], oppCol)) return true;
218 for (let i=0; i<V.size.x; i++) {
219 for (let j=0; j<V.size.y; j++) {
220 if (
221 this.getColor(i, j) == color &&
222 this.getPiece(i, j) == V.QUEEN &&
223 this.isAttacked([i, j], oppCol)
224 ) {
225 return true;
226 }
227 }
228 }
229 return false;
230 }
231
232 // "twoKings" arg for the similar Twokings variant.
233 updateCastleFlags(move, piece, twoKings) {
234 const c = V.GetOppCol(this.turn);
235 const firstRank = (c == "w" ? V.size.x - 1 : 0);
236 // Update castling flags if castling pieces moved or were captured
237 const oppCol = V.GetOppCol(c);
238 const oppFirstRank = V.size.x - 1 - firstRank;
239 if (move.start.x == firstRank) {
240 if (piece == V.KING || (!twoKings && piece == V.QUEEN)) {
241 if (this.castleFlags[c][1] == move.start.y)
242 this.castleFlags[c][1] = 8;
243 else if (this.castleFlags[c][2] == move.start.y)
244 this.castleFlags[c][2] = 8;
245 // Else: the flag is already turned off
246 }
247 }
248 else if (
249 move.start.x == firstRank && //our rook moves?
250 [this.castleFlags[c][0], this.castleFlags[c][3]].includes(move.start.y)
251 ) {
252 const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 3);
253 this.castleFlags[c][flagIdx] = 8;
254 } else if (
255 move.end.x == oppFirstRank && //we took opponent rook?
256 [this.castleFlags[oppCol][0], this.castleFlags[oppCol][3]]
257 .includes(move.end.y)
258 ) {
259 const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 3);
260 this.castleFlags[oppCol][flagIdx] = 8;
261 }
262 }
263
264 // NOTE: do not set queen value to 1000 or so, because there may be several.
265
266 static get SEARCH_DEPTH() {
267 return 2;
268 }
269
270 getNotation(move) {
271 if (move.appear.length == 2) {
272 // Castle: determine the right notation
273 const color = move.appear[0].c;
274 let symbol = (move.appear[0].p == V.QUEEN ? "Q" : "") + "0-0";
275 if (
276 (
277 this.castleFlags[color][1] == move.vanish[0].y &&
278 move.end.y > move.start.y
279 )
280 ||
281 (
282 this.castleFlags[color][2] == move.vanish[0].y &&
283 move.end.y < move.start.y
284 )
285 ) {
286 symbol += "-0";
287 }
288 return symbol;
289 }
290 return super.getNotation(move);
291 }
292
293 };