Debug Knightrelay variant
[vchess.git] / client / src / variants / Suction.js
... / ...
CommitLineData
1import { ChessRules, PiPo, Move } from "@/base_rules";
2
3export const VariantRules = class SuctionRules extends ChessRules {
4 setOtherVariables(fen) {
5 super.setOtherVariables(fen);
6 // Local stack of captures
7 this.cmoves = [];
8 const cmove = fen.split(" ")[5];
9 if (cmove == "-") this.cmoves.push(null);
10 else {
11 this.cmoves.push({
12 start: ChessRules.SquareToCoords(cmove.substr(0, 2)),
13 end: ChessRules.SquareToCoords(cmove.substr(2))
14 });
15 }
16 }
17
18 static IsGoodFen(fen) {
19 if (!ChessRules.IsGoodFen(fen)) return false;
20 const fenParts = fen.split(" ");
21 if (fenParts.length != 6) return false;
22 if (fenParts[5] != "-" && !fenParts[5].match(/^([a-h][1-8]){2}$/))
23 return false;
24 return true;
25 }
26
27 getCmove(move) {
28 if (move.vanish.length == 2)
29 return { start: move.start, end: move.end };
30 return null;
31 }
32
33 getBasicMove([sx, sy], [ex, ey]) {
34 const startColor = this.getColor(sx, sy);
35 const startPiece = this.getPiece(sx, sy);
36 let mv = new Move({
37 appear: [
38 new PiPo({
39 x: ex,
40 y: ey,
41 c: startColor,
42 p: startPiece
43 })
44 ],
45 vanish: [
46 new PiPo({
47 x: sx,
48 y: sy,
49 c: startColor,
50 p: startPiece
51 })
52 ]
53 });
54
55 if (this.board[ex][ey] != V.EMPTY) {
56 const endColor = this.getColor(ex, ey);
57 const endPiece = this.getPiece(ex, ey);
58 mv.vanish.push(
59 new PiPo({
60 x: ex,
61 y: ey,
62 c: endColor,
63 p: endPiece
64 })
65 );
66 mv.appear.push(
67 new PiPo({
68 x: sx,
69 y: sy,
70 c: endColor,
71 p: endPiece
72 })
73 );
74 }
75 return mv;
76 }
77
78 getPotentialPawnMoves([x, y]) {
79 const color = this.turn;
80 let moves = [];
81 const [sizeX, sizeY] = [V.size.x, V.size.y];
82 const shiftX = color == "w" ? -1 : 1;
83 const startRank = color == "w" ? sizeX - 2 : 1;
84 const firstRank = color == "w" ? sizeX - 1 : 0;
85
86 if (x + shiftX >= 0 && x + shiftX < sizeX) {
87 // One square forward
88 if (this.board[x + shiftX][y] == V.EMPTY) {
89 moves.push(
90 this.getBasicMove([x, y], [x + shiftX, y], {
91 c: color,
92 p: "p"
93 })
94 );
95 if (
96 [startRank,firstRank].includes(x) &&
97 this.board[x + 2 * shiftX][y] == V.EMPTY
98 ) {
99 // Two squares jump
100 moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
101 }
102 }
103 // Swaps
104 for (let shiftY of [-1, 1]) {
105 if (
106 y + shiftY >= 0 &&
107 y + shiftY < sizeY &&
108 this.board[x + shiftX][y + shiftY] != V.EMPTY &&
109 this.canTake([x, y], [x + shiftX, y + shiftY])
110 ) {
111 moves.push(
112 this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
113 c: color,
114 p: "p"
115 })
116 );
117 }
118 }
119 }
120
121 // En passant
122 const Lep = this.epSquares.length;
123 const epSquare = this.epSquares[Lep - 1]; //always at least one element
124 if (
125 !!epSquare &&
126 epSquare.x == x + shiftX &&
127 Math.abs(epSquare.y - y) == 1
128 ) {
129 let enpassantMove = this.getBasicMove([x, y], [epSquare.x, epSquare.y]);
130 const oppCol = V.GetOppCol(color);
131 enpassantMove.vanish.push({
132 x: x,
133 y: epSquare.y,
134 p: "p",
135 c: oppCol
136 });
137 enpassantMove.appear.push({
138 x: x,
139 y: y,
140 p: "p",
141 c: oppCol
142 });
143 moves.push(enpassantMove);
144 }
145
146 return moves;
147 }
148
149 getPotentialKingMoves() {
150 return [];
151 }
152
153 // Does m2 un-do m1 ? (to disallow undoing captures)
154 oppositeMoves(m1, m2) {
155 return (
156 m1 &&
157 m2.vanish.length == 2 &&
158 m1.start.x == m2.start.x &&
159 m1.end.x == m2.end.x &&
160 m1.start.y == m2.start.y &&
161 m1.end.y == m2.end.y
162 );
163 }
164
165 filterValid(moves) {
166 if (moves.length == 0) return [];
167 const color = this.turn;
168 return moves.filter(m => {
169 const L = this.cmoves.length; //at least 1: init from FEN
170 return !this.oppositeMoves(this.cmoves[L - 1], m);
171 });
172 }
173
174 updateVariables(move) {
175 super.updateVariables(move);
176 if (move.vanish.length == 2) {
177 // Was opponent king swapped?
178 if (move.vanish[1].p == V.KING)
179 this.kingPos[this.turn] = [move.appear[1].x, move.appear[1].y];
180 }
181 }
182
183 unupdateVariables(move) {
184 super.unupdateVariables(move);
185 if (move.appear.length == 2) {
186 // Was opponent king swapped?
187 if (move.appear[1].p == V.KING)
188 this.kingPos[move.vanish[1].c] = [move.vanish[1].x,move.vanish[1].y];
189 }
190 }
191
192 static GenRandInitFen() {
193 // Add empty cmove:
194 return ChessRules.GenRandInitFen() + " -";
195 }
196
197 getFen() {
198 const L = this.cmoves.length;
199 const cmoveFen = !this.cmoves[L - 1]
200 ? "-"
201 : ChessRules.CoordsToSquare(this.cmoves[L - 1].start) +
202 ChessRules.CoordsToSquare(this.cmoves[L - 1].end);
203 return super.getFen() + " " + cmoveFen;
204 }
205
206 play(move) {
207 this.cmoves.push(this.getCmove(move));
208 super.play(move);
209 }
210
211 undo(move) {
212 this.cmoves.pop();
213 super.undo(move);
214 }
215
216 atLeastOneMove() {
217 return true;
218 }
219
220 getCheckSquares() {
221 return [];
222 }
223
224 getCurrentScore() {
225 const color = this.turn;
226 const kp = this.kingPos[color];
227 if (color == "w" && kp[0] == 0)
228 return "0-1";
229 if (color == "b" && kp[0] == V.size.x - 1)
230 return "1-0";
231 // King is not on the opposite edge: game not over
232 return "*";
233 }
234
235 evalPosition() {
236 // Very simple criterion for now: kings position
237 return this.kingPos["w"][0] + this.kingPos["b"][0];
238 }
239
240 getNotation(move) {
241 // Translate final square
242 const finalSquare = V.CoordsToSquare(move.end);
243
244 const piece = this.getPiece(move.start.x, move.start.y);
245 if (piece == V.PAWN) {
246 // Pawn move
247 let notation = "";
248 if (move.vanish.length == 2) {
249 // Capture
250 const startColumn = V.CoordToColumn(move.start.y);
251 notation = startColumn + "x" + finalSquare;
252 }
253 else notation = finalSquare;
254 return notation;
255 }
256 // Piece movement
257 return (
258 piece.toUpperCase() +
259 (move.vanish.length == 2 ? "x" : "") +
260 finalSquare
261 );
262 }
263};