Fix Omega promotions
[vchess.git] / client / src / variants / Madhouse.js
CommitLineData
a9e1202b
BA
1import { ChessRules, Move, PiPo } from "@/base_rules";
2import { randInt } from "@/utils/alea";
3
4export class MadhouseRules extends ChessRules {
5 hoverHighlight(x, y) {
6 // Testing move validity results in an infinite update loop.
7 // TODO: find a way to test validity anyway.
8 return (this.subTurn == 2 && this.board[x][y] == V.EMPTY);
9 }
10
11 setOtherVariables(fen) {
12 super.setOtherVariables(fen);
13 this.subTurn = 1;
14 this.firstMove = [];
15 }
16
17 getPotentialMovesFrom([x, y]) {
18 if (this.subTurn == 1) return super.getPotentialMovesFrom([x, y]);
19 // subTurn == 2: a move is a click, not handled here
20 return [];
21 }
22
23 filterValid(moves) {
24 if (this.subTurn == 2) return super.filterValid(moves);
25 const color = this.turn;
26 return moves.filter(m => {
27 this.play(m);
28 let res = false;
29 if (m.vanish.length == 1 || m.appear.length == 2)
30 // Standard check:
31 res = !this.underCheck(color);
32 else {
33 // Capture: find landing square not resulting in check
34 const boundary = (m.vanish[1].p != V.PAWN ? [0, 7] : [1, 6]);
35 const sqColor =
36 m.vanish[1].p == V.BISHOP
37 ? (m.vanish[1].x + m.vanish[1].y) % 2
38 : null;
39 outerLoop: for (let i = boundary[0]; i <= boundary[1]; i++) {
40 for (let j=0; j<8; j++) {
41 if (
42 this.board[i][j] == V.EMPTY &&
43 (!sqColor || (i + j) % 2 == sqColor)
44 ) {
45 const tMove = new Move({
46 appear: [
47 new PiPo({
48 x: i,
49 y: j,
50 c: m.vanish[1].c,
51 p: m.vanish[1].p
52 })
53 ],
54 vanish: [],
55 start: { x: -1, y: -1 }
56 });
57 this.play(tMove);
58 const moveOk = !this.underCheck(color);
59 this.undo(tMove);
60 if (moveOk) {
61 res = true;
62 break outerLoop;
63 }
64 }
65 }
66 }
67 }
68 this.undo(m);
69 return res;
70 });
71 }
72
73 getAllValidMoves() {
74 if (this.subTurn == 1) return super.getAllValidMoves();
75 // Subturn == 2: only replacements
76 let moves = [];
77 const L = this.firstMove.length;
78 const fm = this.firstMove[L - 1];
79 const color = this.turn;
80 const oppCol = V.GetOppCol(color);
81 const boundary = (fm.vanish[1].p != V.PAWN ? [0, 7] : [1, 6]);
82 const sqColor =
83 fm.vanish[1].p == V.BISHOP
84 ? (fm.vanish[1].x + fm.vanish[1].y) % 2
85 : null;
86 for (let i = boundary[0]; i < boundary[1]; i++) {
87 for (let j=0; j<8; j++) {
88 if (
89 this.board[i][j] == V.EMPTY &&
90 (!sqColor || (i + j) % 2 == sqColor)
91 ) {
92 const tMove = new Move({
93 appear: [
94 new PiPo({
95 x: i,
96 y: j,
97 c: oppCol,
98 p: fm.vanish[1].p
99 })
100 ],
101 vanish: [],
102 start: { x: -1, y: -1 }
103 });
104 this.play(tMove);
105 const moveOk = !this.underCheck(color);
106 this.undo(tMove);
107 if (moveOk) moves.push(tMove);
108 }
109 }
110 }
111 return moves;
112 }
113
114 doClick(square) {
115 if (isNaN(square[0])) return null;
116 // If subTurn == 2 && square is empty && !underCheck, then replacement
117 if (this.subTurn == 2 && this.board[square[0]][square[1]] == V.EMPTY) {
118 const L = this.firstMove.length;
119 const fm = this.firstMove[L - 1];
120 const color = this.turn;
121 const oppCol = V.GetOppCol(color);
122 if (
123 (fm.vanish[1].p == V.PAWN && [0, 7].includes(square[0])) ||
124 (
125 fm.vanish[1].p == V.BISHOP &&
126 (square[0] + square[1] + fm.vanish[1].x + fm.vanish[1].y) % 2 != 0
127 )
128 ) {
129 // Pawns cannot be replaced on first or last rank,
130 // bishops must be replaced on same square color.
131 return null;
132 }
133 const tMove = new Move({
134 appear: [
135 new PiPo({
136 x: square[0],
137 y: square[1],
138 c: oppCol,
139 p: fm.vanish[1].p
140 })
141 ],
142 vanish: [],
143 start: { x: -1, y: -1 }
144 });
145 this.play(tMove);
146 const moveOk = !this.underCheck(color);
147 this.undo(tMove);
148 if (moveOk) return tMove;
149 }
150 return null;
151 }
152
153 play(move) {
154 move.flags = JSON.stringify(this.aggregateFlags());
155 if (move.vanish.length > 0) {
156 this.epSquares.push(this.getEpSquare(move));
157 this.firstMove.push(move);
158 }
159 V.PlayOnBoard(this.board, move);
160 if (
161 this.subTurn == 2 ||
162 move.vanish.length == 1 ||
163 move.appear.length == 2
164 ) {
165 this.turn = V.GetOppCol(this.turn);
166 this.subTurn = 1;
167 this.movesCount++;
168 }
169 else this.subTurn = 2;
170 if (move.vanish.length > 0) this.postPlay(move);
171 }
172
173 postPlay(move) {
174 if (move.appear[0].p == V.KING)
175 this.kingPos[move.appear[0].c] = [move.appear[0].x, move.appear[0].y];
176 this.updateCastleFlags(move, move.appear[0].p, move.appear[0].c);
177 }
178
179 undo(move) {
180 this.disaggregateFlags(JSON.parse(move.flags));
181 if (move.vanish.length > 0) {
182 this.epSquares.pop();
183 this.firstMove.pop();
184 }
185 V.UndoOnBoard(this.board, move);
186 if (this.subTurn == 2) this.subTurn = 1;
187 else {
188 this.turn = V.GetOppCol(this.turn);
189 this.movesCount--;
190 this.subTurn = (move.vanish.length > 0 ? 1 : 2);
191 }
192 if (move.vanish.length > 0) super.postUndo(move);
193 }
194
195 getComputerMove() {
196 let moves = this.getAllValidMoves();
197 if (moves.length == 0) return null;
198 // Custom "search" at depth 1 (for now. TODO?)
199 const maxeval = V.INFINITY;
200 const color = this.turn;
201 const initEval = this.evalPosition();
202 moves.forEach(m => {
203 this.play(m);
204 m.eval = (color == "w" ? -1 : 1) * maxeval;
205 if (m.vanish.length == 2 && m.appear.length == 1) {
206 const moves2 = this.getAllValidMoves();
207 m.next = moves2[0];
208 moves2.forEach(m2 => {
209 this.play(m2);
210 const score = this.getCurrentScore();
211 let mvEval = 0;
212 if (["1-0", "0-1"].includes(score))
213 mvEval = (score == "1-0" ? 1 : -1) * maxeval;
214 else if (score == "*")
215 // Add small fluctuations to avoid dropping pieces always on the
216 // first square available.
217 mvEval = initEval + 0.05 - Math.random() / 10;
218 if (
219 (color == 'w' && mvEval > m.eval) ||
220 (color == 'b' && mvEval < m.eval)
221 ) {
222 m.eval = mvEval;
223 m.next = m2;
224 }
225 this.undo(m2);
226 });
227 }
228 else {
229 const score = this.getCurrentScore();
230 if (score != "1/2") {
231 if (score != "*") m.eval = (score == "1-0" ? 1 : -1) * maxeval;
232 else m.eval = this.evalPosition();
233 }
234 }
235 this.undo(m);
236 });
237 moves.sort((a, b) => {
238 return (color == "w" ? 1 : -1) * (b.eval - a.eval);
239 });
240 let candidates = [0];
241 for (let i = 1; i < moves.length && moves[i].eval == moves[0].eval; i++)
242 candidates.push(i);
243 const mIdx = candidates[randInt(candidates.length)];
244 if (!moves[mIdx].next) return moves[mIdx];
245 const move2 = moves[mIdx].next;
246 delete moves[mIdx]["next"];
247 return [moves[mIdx], move2];
248 }
249
250 getNotation(move) {
251 if (move.vanish.length > 0) return super.getNotation(move);
252 // Replacement:
253 const piece =
254 move.appear[0].p != V.PAWN ? move.appear[0].p.toUpperCase() : "";
255 return piece + "@" + V.CoordsToSquare(move.end);
256 }
257};