A few fixes, and write rules for Grand + Wildebeest
[vchess.git] / public / javascripts / variants / Wildebeest.js
1 //https://www.chessvariants.com/large.dir/wildebeest.html
2 class WildebeestRules extends ChessRules
3 {
4 static getPpath(b)
5 {
6 const V = VariantRules;
7 return ([V.CAMEL,V.WILDEBEEST].includes(b[1]) ? "Wildebeest/" : "") + b;
8 }
9
10 static get size() { return [10,11]; }
11
12 static get CAMEL() { return 'c'; }
13 static get WILDEBEEST() { return 'w'; }
14
15 static get steps() {
16 return Object.assign(
17 ChessRules.steps, //add camel moves:
18 {'c': [ [-3,-1],[-3,1],[-1,-3],[-1,3],[1,-3],[1,3],[3,-1],[3,1] ]}
19 );
20 }
21
22 // En-passant after 2-sq or 3-sq jumps
23 getEpSquare(move)
24 {
25 const [sx,sy,ex] = [move.start.x,move.start.y,move.end.x];
26 if (this.getPiece(sx,sy) == VariantRules.PAWN && Math.abs(sx - ex) >= 2)
27 {
28 const step = (ex-sx) / Math.abs(ex-sx);
29 let res = [{
30 x: sx + step,
31 y: sy
32 }];
33 if (sx + 2*step != ex) //3-squares move
34 {
35 res.push({
36 x: sx + 2*step,
37 y: sy
38 });
39 }
40 return res;
41 }
42 return undefined; //default
43 }
44
45 getPotentialMovesFrom([x,y])
46 {
47 switch (this.getPiece(x,y))
48 {
49 case VariantRules.CAMEL:
50 return this.getPotentialCamelMoves([x,y]);
51 case VariantRules.WILDEBEEST:
52 return this.getPotentialWildebeestMoves([x,y]);
53 default:
54 return super.getPotentialMovesFrom([x,y])
55 }
56 }
57
58 // Pawns jump 2 or 3 squares, and promote to queen or wildebeest
59 getPotentialPawnMoves([x,y])
60 {
61 const color = this.turn;
62 let moves = [];
63 const V = VariantRules;
64 const [sizeX,sizeY] = VariantRules.size;
65 const shift = (color == "w" ? -1 : 1);
66 const startRanks = (color == "w" ? [sizeX-2,sizeX-3] : [1,2]);
67 const lastRank = (color == "w" ? 0 : sizeX-1);
68
69 if (x+shift >= 0 && x+shift < sizeX && x+shift != lastRank)
70 {
71 // Normal moves
72 if (this.board[x+shift][y] == V.EMPTY)
73 {
74 moves.push(this.getBasicMove([x,y], [x+shift,y]));
75 if (startRanks.includes(x) && this.board[x+2*shift][y] == V.EMPTY)
76 {
77 // Two squares jump
78 moves.push(this.getBasicMove([x,y], [x+2*shift,y]));
79 if (x == startRanks[0] && this.board[x+3*shift][y] == V.EMPTY)
80 {
81 // 3-squares jump
82 moves.push(this.getBasicMove([x,y], [x+3*shift,y]));
83 }
84 }
85 }
86 // Captures
87 if (y>0 && this.canTake([x,y], [x+shift,y-1]) && this.board[x+shift][y-1] != V.EMPTY)
88 moves.push(this.getBasicMove([x,y], [x+shift,y-1]));
89 if (y<sizeY-1 && this.canTake([x,y], [x+shift,y+1]) && this.board[x+shift][y+1] != V.EMPTY)
90 moves.push(this.getBasicMove([x,y], [x+shift,y+1]));
91 }
92
93 if (x+shift == lastRank)
94 {
95 // Promotion
96 let promotionPieces = [V.QUEEN,V.WILDEBEEST];
97 promotionPieces.forEach(p => {
98 // Normal move
99 if (this.board[x+shift][y] == V.EMPTY)
100 moves.push(this.getBasicMove([x,y], [x+shift,y], {c:color,p:p}));
101 // Captures
102 if (y>0 && this.canTake([x,y], [x+shift,y-1]) && this.board[x+shift][y-1] != V.EMPTY)
103 moves.push(this.getBasicMove([x,y], [x+shift,y-1], {c:color,p:p}));
104 if (y<sizeY-1 && this.canTake([x,y], [x+shift,y+1]) && this.board[x+shift][y+1] != V.EMPTY)
105 moves.push(this.getBasicMove([x,y], [x+shift,y+1], {c:color,p:p}));
106 });
107 }
108
109 // En passant
110 const Lep = this.epSquares.length;
111 const epSquare = Lep>0 ? this.epSquares[Lep-1] : undefined;
112 if (!!epSquare)
113 {
114 for (let epsq of epSquare)
115 {
116 // TODO: some redundant checks
117 if (epsq.x == x+shift && Math.abs(epsq.y - y) == 1)
118 {
119 let epStep = epsq.y - y;
120 var enpassantMove = this.getBasicMove([x,y], [x+shift,y+epStep]);
121 enpassantMove.vanish.push({
122 x: x,
123 y: y+epStep,
124 p: 'p',
125 c: this.getColor(x,y+epStep)
126 });
127 moves.push(enpassantMove);
128 }
129 }
130 }
131
132 return moves;
133 }
134
135 // TODO: wildebeest castle
136
137 getPotentialCamelMoves(sq)
138 {
139 return this.getSlideNJumpMoves(sq, VariantRules.steps[VariantRules.CAMEL], "oneStep");
140 }
141
142 getPotentialWildebeestMoves(sq)
143 {
144 const V = VariantRules;
145 return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep");
146 }
147
148 isAttacked(sq, colors)
149 {
150 return super.isAttacked(sq, colors)
151 || this.isAttackedByCamel(sq, colors)
152 || this.isAttackedByWildebeest(sq, colors);
153 }
154
155 isAttackedByCamel(sq, colors)
156 {
157 return this.isAttackedBySlideNJump(sq, colors,
158 VariantRules.CAMEL, VariantRules.steps[VariantRules.CAMEL], "oneStep");
159 }
160
161 isAttackedByWildebeest(sq, colors)
162 {
163 const V = VariantRules;
164 return this.isAttackedBySlideNJump(sq, colors, V.WILDEBEEST,
165 V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep");
166 }
167
168 checkGameEnd()
169 {
170 // No valid move: game is lost (stalemate is a win)
171 return this.turn == "w" ? "0-1" : "1-0";
172 }
173
174 static get VALUES() {
175 return Object.assign(
176 ChessRules.VALUES,
177 {'c': 3, 'w': 7} //experimental
178 );
179 }
180
181 static get SEARCH_DEPTH() { return 2; }
182
183 static GenRandInitFen()
184 {
185 let pieces = [new Array(10), new Array(10)];
186 // Shuffle pieces on first and last rank
187 for (let c = 0; c <= 1; c++)
188 {
189 let positions = _.range(11);
190
191 // Get random squares for bishops
192 let randIndex = 2 * _.random(5);
193 let bishop1Pos = positions[randIndex];
194 // The second bishop must be on a square of different color
195 let randIndex_tmp = 2 * _.random(4) + 1;
196 let bishop2Pos = positions[randIndex_tmp];
197 // Remove chosen squares
198 positions.splice(Math.max(randIndex,randIndex_tmp), 1);
199 positions.splice(Math.min(randIndex,randIndex_tmp), 1);
200
201 // Get random squares for knights
202 randIndex = _.random(8);
203 let knight1Pos = positions[randIndex];
204 positions.splice(randIndex, 1);
205 randIndex = _.random(7);
206 let knight2Pos = positions[randIndex];
207 positions.splice(randIndex, 1);
208
209 // Get random square for queen
210 randIndex = _.random(6);
211 let queenPos = positions[randIndex];
212 positions.splice(randIndex, 1);
213
214 // ...random square for camels
215 randIndex = _.random(5);
216 let camel1Pos = positions[randIndex];
217 positions.splice(randIndex, 1);
218 randIndex = _.random(4);
219 let camel2Pos = positions[randIndex];
220 positions.splice(randIndex, 1);
221
222 // ...random square for wildebeest
223 randIndex = _.random(3);
224 let wildebeestPos = positions[randIndex];
225 positions.splice(randIndex, 1);
226
227 // Rooks and king positions are now fixed, because of the ordering rook-king-rook
228 let rook1Pos = positions[0];
229 let kingPos = positions[1];
230 let rook2Pos = positions[2];
231
232 // Finally put the shuffled pieces in the board array
233 pieces[c][rook1Pos] = 'r';
234 pieces[c][knight1Pos] = 'n';
235 pieces[c][bishop1Pos] = 'b';
236 pieces[c][queenPos] = 'q';
237 pieces[c][camel1Pos] = 'c';
238 pieces[c][camel2Pos] = 'c';
239 pieces[c][wildebeestPos] = 'w';
240 pieces[c][kingPos] = 'k';
241 pieces[c][bishop2Pos] = 'b';
242 pieces[c][knight2Pos] = 'n';
243 pieces[c][rook2Pos] = 'r';
244 }
245 let fen = pieces[0].join("") +
246 "/ppppppppppp/11/11/11/11/11/11/PPPPPPPPPPP/" +
247 pieces[1].join("").toUpperCase() +
248 " 1111";
249 return fen;
250 }
251 }