[Paco-Sako] At least forbid to castle when under direct check
[vchess.git] / client / src / variants / Hiddenqueen.js
1 import { ChessRules, PiPo, Move } from "@/base_rules";
2 import { ArrayFun } from "@/utils/array";
3 import { randInt } from "@/utils/alea";
4
5 export class HiddenqueenRules extends ChessRules {
6
7 // Analyse in Hiddenqueen mode makes no sense
8 static get CanAnalyze() {
9 return false;
10 }
11
12 static get HIDDEN_QUEEN() {
13 return 't';
14 }
15
16 static get SomeHiddenMoves() {
17 return true;
18 }
19
20 static get PIECES() {
21 return ChessRules.PIECES.concat([V.HIDDEN_QUEEN]);
22 }
23
24 getPiece(i, j) {
25 const piece = this.board[i][j].charAt(1);
26 if (
27 piece != V.HIDDEN_QUEEN ||
28 // 'side' is used to determine what I see: a pawn or a (hidden)queen?
29 this.getColor(i, j) == this.side
30 ) {
31 return piece;
32 }
33 return V.PAWN;
34 }
35
36 getPpath(b, color, score) {
37 if (b[1] == V.HIDDEN_QUEEN) {
38 // Supposed to be hidden.
39 if (score == "*" && (!color || color != b[0]))
40 return b[0] + "p";
41 return "Hiddenqueen/" + b[0] + "t";
42 }
43 return b;
44 }
45
46 getEpSquare(moveOrSquare) {
47 if (!moveOrSquare) return undefined;
48 if (typeof moveOrSquare === "string") {
49 const square = moveOrSquare;
50 if (square == "-") return undefined;
51 return V.SquareToCoords(square);
52 }
53 const move = moveOrSquare;
54 const s = move.start,
55 e = move.end;
56 const color = move.vanish[0].c;
57 if (
58 s.y == e.y &&
59 Math.abs(s.x - e.x) == 2 &&
60 ((color == 'w' && s.x == 6) || (color == 'b' && s.x == 1)) &&
61 [V.PAWN, V.HIDDEN_QUEEN].includes(move.vanish[0].p)
62 ) {
63 return {
64 x: (s.x + e.x) / 2,
65 y: s.y
66 };
67 }
68 return undefined; //default
69 }
70
71 isValidPawnMove(move) {
72 const color = move.vanish[0].c;
73 const pawnShift = color == "w" ? -1 : 1;
74 const startRank = color == "w" ? V.size.x - 2 : 1;
75 return (
76 (
77 move.end.x - move.start.x == pawnShift &&
78 (
79 (
80 // Normal move
81 move.end.y == move.start.y &&
82 this.board[move.end.x][move.end.y] == V.EMPTY
83 )
84 ||
85 (
86 // Capture
87 Math.abs(move.end.y - move.start.y) == 1 &&
88 this.board[move.end.x][move.end.y] != V.EMPTY
89 )
90 )
91 )
92 ||
93 (
94 // Two-spaces initial jump
95 move.start.x == startRank &&
96 move.end.y == move.start.y &&
97 move.end.x - move.start.x == 2 * pawnShift &&
98 this.board[move.end.x][move.end.y] == V.EMPTY
99 )
100 );
101 }
102
103 getPotentialMovesFrom([x, y]) {
104 if (this.getPiece(x, y) == V.HIDDEN_QUEEN) {
105 const pawnMoves = this.getPotentialPawnMoves([x, y]);
106 let queenMoves = super.getPotentialQueenMoves([x, y]);
107 // Remove from queen moves those corresponding to a pawn move:
108 queenMoves = queenMoves
109 .filter(m => !this.isValidPawnMove(m))
110 // Hidden queen is revealed if moving like a queen:
111 .map(m => {
112 m.appear[0].p = V.QUEEN;
113 return m;
114 });
115 return pawnMoves.concat(queenMoves);
116 }
117 return super.getPotentialMovesFrom([x, y]);
118 }
119
120 getEnpassantCaptures([x, y], shiftX) {
121 const Lep = this.epSquares.length;
122 const epSquare = this.epSquares[Lep - 1];
123 let enpassantMove = null;
124 if (
125 !!epSquare &&
126 epSquare.x == x + shiftX &&
127 Math.abs(epSquare.y - y) == 1
128 ) {
129 enpassantMove = this.getBasicMove([x, y], [epSquare.x, epSquare.y]);
130 enpassantMove.vanish.push({
131 x: x,
132 y: epSquare.y,
133 // Captured piece may be a hidden queen
134 p: this.board[x][epSquare.y][1],
135 c: this.getColor(x, epSquare.y)
136 });
137 }
138 return !!enpassantMove ? [enpassantMove] : [];
139 }
140
141 getPotentialPawnMoves([x, y]) {
142 const piece = this.getPiece(x, y);
143 const promotions =
144 piece == V.PAWN
145 ? [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]
146 : [V.QUEEN]; //hidden queen revealed
147 return super.getPotentialPawnMoves([x, y], promotions);
148 }
149
150 getPossibleMovesFrom(sq) {
151 this.side = this.turn;
152 return this.filterValid(this.getPotentialMovesFrom(sq));
153 }
154
155 static GenRandInitFen(randomness) {
156 let fen = ChessRules.GenRandInitFen(randomness);
157 // Place hidden queens at random (always):
158 let hiddenQueenPos = randInt(8);
159 let pawnRank = "PPPPPPPP".split("");
160 pawnRank[hiddenQueenPos] = "T";
161 fen = fen.replace("PPPPPPPP", pawnRank.join(""));
162 hiddenQueenPos = randInt(8);
163 pawnRank = "pppppppp".split("");
164 pawnRank[hiddenQueenPos] = "t";
165 fen = fen.replace("pppppppp", pawnRank.join(""));
166 return fen;
167 }
168
169 postPlay(move) {
170 super.postPlay(move);
171 if (move.vanish.length == 2 && move.vanish[1].p == V.KING)
172 // We took opponent king
173 this.kingPos[this.turn] = [-1, -1];
174 }
175
176 preUndo(move) {
177 super.preUndo(move);
178 const oppCol = this.turn;
179 if (this.kingPos[oppCol][0] < 0)
180 // Move takes opponent's king:
181 this.kingPos[oppCol] = [move.vanish[1].x, move.vanish[1].y];
182 }
183
184 underCheck(color) {
185 if (this.kingPos[color][0] < 0) return false;
186 return super.underCheck(color);
187 }
188
189 getCurrentScore() {
190 const color = this.turn;
191 if (this.kingPos[color][0] < 0)
192 // King disappeared
193 return (color == "w" ? "0-1" : "1-0");
194 const oldSide = this.side;
195 this.side = color;
196 const res = super.getCurrentScore();
197 this.side = oldSide;
198 return res;
199 }
200
201 // Search is biased, so not really needed to explore deeply
202 static get SEARCH_DEPTH() {
203 return 2;
204 }
205
206 static get VALUES() {
207 return Object.assign(
208 { t: 9 },
209 ChessRules.VALUES
210 );
211 }
212
213 getComputerMove() {
214 this.side = this.turn;
215 return super.getComputerMove();
216 }
217
218 getNotation(move) {
219 // Not using getPiece() method because it would transform HQ into pawn:
220 if (this.board[move.start.x][move.start.y].charAt(1) != V.HIDDEN_QUEEN)
221 return super.getNotation(move);
222 const finalSquare = V.CoordsToSquare(move.end);
223 if (move.appear[0].p == V.QUEEN) {
224 return (
225 "Q" +
226 (move.vanish.length > move.appear.length ? "x" : "") +
227 finalSquare
228 );
229 }
230 // Do not reveal hidden queens playing as pawns
231 let notation = "";
232 if (move.vanish.length == 2)
233 // Capture
234 notation = V.CoordToColumn(move.start.y) + "x" + finalSquare;
235 else notation = finalSquare;
236 return notation;
237 }
238
239 };