Update TODO + server update page
[vchess.git] / client / src / variants / Losers.js
... / ...
CommitLineData
1import { ChessRules } from "@/base_rules";
2import { ArrayFun } from "@/utils/array";
3import { randInt } from "@/utils/alea";
4
5export const VariantRules = class LosersRules extends ChessRules {
6 static get HasFlags() {
7 return false;
8 }
9
10 getPotentialPawnMoves([x, y]) {
11 let moves = super.getPotentialPawnMoves([x, y]);
12
13 // Complete with promotion(s) into king, if possible
14 const color = this.turn;
15 const shift = color == "w" ? -1 : 1;
16 const lastRank = color == "w" ? 0 : V.size.x - 1;
17 if (x + shift == lastRank) {
18 // Normal move
19 if (this.board[x + shift][y] == V.EMPTY)
20 moves.push(
21 this.getBasicMove([x, y], [x + shift, y], { c: color, p: V.KING })
22 );
23 // Captures
24 if (
25 y > 0 &&
26 this.canTake([x, y], [x + shift, y - 1]) &&
27 this.board[x + shift][y - 1] != V.EMPTY
28 ) {
29 moves.push(
30 this.getBasicMove([x, y], [x + shift, y - 1], { c: color, p: V.KING })
31 );
32 }
33 if (
34 y < V.size.y - 1 &&
35 this.canTake([x, y], [x + shift, y + 1]) &&
36 this.board[x + shift][y + 1] != V.EMPTY
37 ) {
38 moves.push(
39 this.getBasicMove([x, y], [x + shift, y + 1], { c: color, p: V.KING })
40 );
41 }
42 }
43
44 return moves;
45 }
46
47 getPotentialKingMoves(sq) {
48 // No castle:
49 return this.getSlideNJumpMoves(
50 sq,
51 V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
52 "oneStep"
53 );
54 }
55
56 // Stop at the first capture found (if any)
57 atLeastOneCapture() {
58 const color = this.turn;
59 const oppCol = V.GetOppCol(color);
60 for (let i = 0; i < V.size.x; i++) {
61 for (let j = 0; j < V.size.y; j++) {
62 if (this.board[i][j] != V.EMPTY && this.getColor(i, j) != oppCol) {
63 const moves = this.getPotentialMovesFrom([i, j]);
64 if (moves.length > 0) {
65 for (let k = 0; k < moves.length; k++) {
66 if (
67 moves[k].vanish.length == 2 &&
68 this.filterValid([moves[k]]).length > 0
69 )
70 return true;
71 }
72 }
73 }
74 }
75 }
76 return false;
77 }
78
79 // Trim all non-capturing moves
80 static KeepCaptures(moves) {
81 return moves.filter(m => {
82 return m.vanish.length == 2;
83 });
84 }
85
86 getPossibleMovesFrom(sq) {
87 let moves = this.filterValid(this.getPotentialMovesFrom(sq));
88 // This is called from interface: we need to know if a capture is possible
89 if (this.atLeastOneCapture()) moves = V.KeepCaptures(moves);
90 return moves;
91 }
92
93 getAllValidMoves() {
94 let moves = super.getAllValidMoves();
95 if (
96 moves.some(m => {
97 return m.vanish.length == 2;
98 })
99 )
100 moves = V.KeepCaptures(moves);
101 return moves;
102 }
103
104 underCheck() {
105 return false; //No notion of check
106 }
107
108 getCheckSquares() {
109 return [];
110 }
111
112 // No variables update because no royal king + no castling
113 updateVariables() {}
114 unupdateVariables() {}
115
116 getCurrentScore() {
117 if (this.atLeastOneMove())
118 // game not over
119 return "*";
120
121 // No valid move: the side who cannot move wins
122 return this.turn == "w" ? "1-0" : "0-1";
123 }
124
125 static get VALUES() {
126 // Experimental...
127 return {
128 p: 1,
129 r: 7,
130 n: 3,
131 b: 3,
132 q: 5,
133 k: 5
134 };
135 }
136
137 static get SEARCH_DEPTH() {
138 return 4;
139 }
140
141 evalPosition() {
142 return -super.evalPosition(); //better with less material
143 }
144
145 static GenRandInitFen(randomness) {
146 if (randomness == 0)
147 return "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0 -";
148
149 let pieces = { w: new Array(8), b: new Array(8) };
150 // Shuffle pieces on first and last rank
151 for (let c of ["w", "b"]) {
152 if (c == 'b' && randomness == 1) {
153 pieces['b'] = pieces['w'];
154 break;
155 }
156
157 let positions = ArrayFun.range(8);
158
159 // Get random squares for bishops
160 let randIndex = 2 * randInt(4);
161 let bishop1Pos = positions[randIndex];
162 // The second bishop must be on a square of different color
163 let randIndex_tmp = 2 * randInt(4) + 1;
164 let bishop2Pos = positions[randIndex_tmp];
165 // Remove chosen squares
166 positions.splice(Math.max(randIndex, randIndex_tmp), 1);
167 positions.splice(Math.min(randIndex, randIndex_tmp), 1);
168
169 // Get random squares for knights
170 randIndex = randInt(6);
171 let knight1Pos = positions[randIndex];
172 positions.splice(randIndex, 1);
173 randIndex = randInt(5);
174 let knight2Pos = positions[randIndex];
175 positions.splice(randIndex, 1);
176
177 // Get random square for queen
178 randIndex = randInt(4);
179 let queenPos = positions[randIndex];
180 positions.splice(randIndex, 1);
181
182 // Random square for king (no castle)
183 randIndex = randInt(3);
184 let kingPos = positions[randIndex];
185 positions.splice(randIndex, 1);
186
187 // Rooks positions are now fixed
188 let rook1Pos = positions[0];
189 let rook2Pos = positions[1];
190
191 // Finally put the shuffled pieces in the board array
192 pieces[c][rook1Pos] = "r";
193 pieces[c][knight1Pos] = "n";
194 pieces[c][bishop1Pos] = "b";
195 pieces[c][queenPos] = "q";
196 pieces[c][kingPos] = "k";
197 pieces[c][bishop2Pos] = "b";
198 pieces[c][knight2Pos] = "n";
199 pieces[c][rook2Pos] = "r";
200 }
201 return (
202 pieces["b"].join("") +
203 "/pppppppp/8/8/8/8/PPPPPPPP/" +
204 pieces["w"].join("").toUpperCase() +
205 // En-passant allowed, but no flags
206 " w 0 -"
207 );
208 }
209};