Add temporary patch for preset challenges
[vchess.git] / client / src / variants / Doublemove1.js
1 import { ChessRules } from "@/base_rules";
2
3 export class Doublemove1Rules extends ChessRules {
4
5 static IsGoodEnpassant(enpassant) {
6 const squares = enpassant.split(",");
7 if (squares.length > 2) return false;
8 for (let sq of squares) {
9 if (sq != "-") {
10 const ep = V.SquareToCoords(sq);
11 if (isNaN(ep.x) || !V.OnBoard(ep)) return false;
12 }
13 }
14 return true;
15 }
16
17 // There may be 2 enPassant squares (if 2 pawns jump 2 squares in same turn)
18 getEnpassantFen() {
19 return this.epSquares[this.epSquares.length - 1].map(
20 epsq => epsq === undefined
21 ? "-" //no en-passant
22 : V.CoordsToSquare(epsq)
23 ).join(",");
24 }
25
26 setOtherVariables(fen) {
27 const parsedFen = V.ParseFen(fen);
28 this.setFlags(parsedFen.flags);
29 this.epSquares = [parsedFen.enpassant.split(",").map(sq => {
30 if (sq != "-") return V.SquareToCoords(sq);
31 return undefined;
32 })];
33 this.scanKings(fen);
34 this.turn = parsedFen.turn;
35 this.subTurn = 1;
36 }
37
38 getEnpassantCaptures([x, y], shiftX) {
39 let moves = [];
40 // En passant: always OK if subturn 1,
41 // OK on subturn 2 only if enPassant was played at subturn 1
42 // (and if there are two e.p. squares available).
43 const Lep = this.epSquares.length;
44 const epSquares = this.epSquares[Lep - 1]; //always at least one element
45 let epSqs = [];
46 epSquares.forEach(sq => {
47 if (sq) epSqs.push(sq);
48 });
49 if (epSqs.length == 0) return moves;
50 const oppCol = V.GetOppCol(this.getColor(x, y));
51 for (let sq of epSqs) {
52 if (
53 this.subTurn == 1 ||
54 (epSqs.length == 2 &&
55 // Was this en-passant capture already played at subturn 1 ?
56 // (Or maybe the opponent filled the en-passant square with a piece)
57 this.board[epSqs[0].x][epSqs[0].y] != V.EMPTY)
58 ) {
59 if (
60 sq.x == x + shiftX &&
61 Math.abs(sq.y - y) == 1 &&
62 // Add condition "enemy pawn must be present"
63 this.getPiece(x, sq.y) == V.PAWN &&
64 this.getColor(x, sq.y) == oppCol
65 ) {
66 let epMove = this.getBasicMove([x, y], [sq.x, sq.y]);
67 epMove.vanish.push({
68 x: x,
69 y: sq.y,
70 p: "p",
71 c: oppCol
72 });
73 moves.push(epMove);
74 }
75 }
76 }
77 return moves;
78 }
79
80 atLeastOneMove() {
81 const color = this.turn;
82 for (let i = 0; i < V.size.x; i++) {
83 for (let j = 0; j < V.size.y; j++) {
84 if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) {
85 const moves = this.getPotentialMovesFrom([i, j]);
86 if (moves.length > 0) {
87 for (let k = 0; k < moves.length; k++) {
88 const m = moves[k];
89 // NOTE: not using play() here (=> infinite loop)
90 V.PlayOnBoard(this.board, m);
91 if (m.vanish[0].p == V.KING)
92 this.kingPos[color] = [m.appear[0].x, m.appear[0].y];
93 const res = !this.underCheck(color);
94 V.UndoOnBoard(this.board, m);
95 if (m.vanish[0].p == V.KING)
96 this.kingPos[color] = [m.start.x, m.start.y];
97 if (res) return true;
98 }
99 }
100 }
101 }
102 }
103 return false;
104 }
105
106 play(move) {
107 move.flags = JSON.stringify(this.aggregateFlags());
108 move.turn = [this.turn, this.subTurn];
109 V.PlayOnBoard(this.board, move);
110 const epSq = this.getEpSquare(move);
111 const oppCol = V.GetOppCol(this.turn);
112 if (this.movesCount == 0) {
113 // First move in game
114 this.turn = "b";
115 this.epSquares.push([epSq]);
116 this.movesCount = 1;
117 }
118 // Does this move give check on subturn 1 or reach stalemate?
119 // If yes, skip subturn 2
120 else if (
121 this.subTurn == 1 &&
122 (
123 this.underCheck(V.GetOppCol(this.turn)) ||
124 !this.atLeastOneMove()
125 )
126 ) {
127 this.turn = oppCol;
128 this.epSquares.push([epSq]);
129 move.checkOnSubturn1 = true;
130 this.movesCount++;
131 }
132 else {
133 if (this.subTurn == 2) {
134 this.turn = oppCol;
135 let lastEpsq = this.epSquares[this.epSquares.length - 1];
136 lastEpsq.push(epSq);
137 }
138 else {
139 this.epSquares.push([epSq]);
140 this.movesCount++;
141 }
142 this.subTurn = 3 - this.subTurn;
143 }
144 this.postPlay(move);
145 }
146
147 postPlay(move) {
148 const c = move.turn[0];
149 const piece = move.vanish[0].p;
150 const firstRank = c == "w" ? V.size.x - 1 : 0;
151
152 if (piece == V.KING) {
153 this.kingPos[c] = [move.appear[0].x, move.appear[0].y];
154 this.castleFlags[c] = [V.size.y, V.size.y];
155 return;
156 }
157 const oppCol = V.GetOppCol(c);
158 const oppFirstRank = V.size.x - 1 - firstRank;
159 if (
160 move.start.x == firstRank && //our rook moves?
161 this.castleFlags[c].includes(move.start.y)
162 ) {
163 const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1);
164 this.castleFlags[c][flagIdx] = V.size.y;
165 }
166 if (
167 move.end.x == oppFirstRank && //we took opponent rook?
168 this.castleFlags[oppCol].includes(move.end.y)
169 ) {
170 const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1);
171 this.castleFlags[oppCol][flagIdx] = V.size.y;
172 }
173 }
174
175 undo(move) {
176 this.disaggregateFlags(JSON.parse(move.flags));
177 V.UndoOnBoard(this.board, move);
178 if (this.movesCount == 1 || !!move.checkOnSubturn1 || this.subTurn == 2) {
179 // The move may not be full, but is fully undone:
180 this.epSquares.pop();
181 // Moves counter was just incremented:
182 this.movesCount--;
183 }
184 else {
185 // Undo the second half of a move
186 let lastEpsq = this.epSquares[this.epSquares.length - 1];
187 lastEpsq.pop();
188 }
189 this.turn = move.turn[0];
190 this.subTurn = move.turn[1];
191 super.postUndo(move);
192 }
193
194 static get VALUES() {
195 return {
196 p: 1,
197 r: 5,
198 n: 3,
199 b: 3,
200 q: 7, //slightly less than in orthodox game
201 k: 1000
202 };
203 }
204
205 // No alpha-beta here, just adapted min-max at depth 2(+1)
206 getComputerMove() {
207 const maxeval = V.INFINITY;
208 const color = this.turn;
209 const oppCol = V.GetOppCol(this.turn);
210
211 // Search best (half) move for opponent turn
212 const getBestMoveEval = () => {
213 let score = this.getCurrentScore();
214 if (score != "*") {
215 if (score == "1/2") return 0;
216 return maxeval * (score == "1-0" ? 1 : -1);
217 }
218 let moves = this.getAllValidMoves();
219 let res = oppCol == "w" ? -maxeval : maxeval;
220 for (let m of moves) {
221 this.play(m);
222 score = this.getCurrentScore();
223 // Now turn is oppCol,2 if m doesn't give check
224 // Otherwise it's color,1. In both cases the next test makes sense
225 if (score != "*") {
226 if (score == "1/2")
227 res = oppCol == "w" ? Math.max(res, 0) : Math.min(res, 0);
228 else {
229 // Found a mate
230 this.undo(m);
231 return maxeval * (score == "1-0" ? 1 : -1);
232 }
233 }
234 const evalPos = this.evalPosition();
235 res = oppCol == "w" ? Math.max(res, evalPos) : Math.min(res, evalPos);
236 this.undo(m);
237 }
238 return res;
239 };
240
241 const moves11 = this.getAllValidMoves();
242 let doubleMove = null;
243 let bestEval = Number.POSITIVE_INFINITY * (color == 'w' ? -1 : 1);
244 // Rank moves using a min-max at depth 2
245 for (let i = 0; i < moves11.length; i++) {
246 this.play(moves11[i]);
247 if (this.turn != color) {
248 // We gave check with last move: search the best opponent move
249 const evalM = getBestMoveEval() + 0.05 - Math.random() / 10;
250 if (
251 (color == 'w' && evalM > bestEval) ||
252 (color == 'b' && evalM < bestEval)
253 ) {
254 doubleMove = moves11[i];
255 bestEval = evalM;
256 }
257 }
258 else {
259 let moves12 = this.getAllValidMoves();
260 for (let j = 0; j < moves12.length; j++) {
261 this.play(moves12[j]);
262 const evalM = getBestMoveEval() + 0.05 - Math.random() / 10
263 if (
264 (color == 'w' && evalM > bestEval) ||
265 (color == 'b' && evalM < bestEval)
266 ) {
267 doubleMove = [moves11[i], moves12[j]];
268 bestEval = evalM;
269 }
270 this.undo(moves12[j]);
271 }
272 }
273 this.undo(moves11[i]);
274 }
275 return doubleMove;
276 }
277
278 };