Some simplifactions, a few fixes, update TODO
[vchess.git] / client / src / variants / Orda.js
1 import { ChessRules } from "@/base_rules";
2 import { ArrayFun } from "@/utils/array";
3 import { randInt } from "@/utils/alea";
4
5 export class OrdaRules extends ChessRules {
6
7 static get PawnSpecs() {
8 return Object.assign(
9 {},
10 ChessRules.PawnSpecs,
11 { promotions: [V.QUEEN, V.KHESHIG] }
12 );
13 }
14
15 static IsGoodFlags(flags) {
16 // Only white can castle
17 return !!flags.match(/^[a-z]{2,2}$/);
18 }
19
20 getPpath(b) {
21 if (b[0] == 'b' || b[1] == 'h')
22 // Horde piece or white promoted pawn in kheshig
23 return "Orda/" + b;
24 return b;
25 }
26
27 static GenRandInitFen(randomness) {
28 if (randomness == 0)
29 return "lhaykahl/8/pppppppp/8/8/8/PPPPPPPP/RNBQKBNR w 0 ah -";
30
31 // Mapping kingdom --> horde:
32 const piecesMap = {
33 'r': 'l',
34 'n': 'h',
35 'b': 'a',
36 'q': 'y',
37 'k': 'k'
38 };
39
40 let pieces = { w: new Array(8), b: new Array(8) };
41 let flags = "";
42 // Shuffle pieces on first (and last rank if randomness == 2)
43 for (let c of ["w", "b"]) {
44 if (c == 'b' && randomness == 1) {
45 pieces['b'] = pieces['w'].map(p => piecesMap[p]);
46 break;
47 }
48
49 // TODO: same code as in base_rules. Should extract and factorize?
50
51 let positions = ArrayFun.range(8);
52
53 let randIndex = 2 * randInt(4);
54 const bishop1Pos = positions[randIndex];
55 let randIndex_tmp = 2 * randInt(4) + 1;
56 const bishop2Pos = positions[randIndex_tmp];
57 positions.splice(Math.max(randIndex, randIndex_tmp), 1);
58 positions.splice(Math.min(randIndex, randIndex_tmp), 1);
59
60 randIndex = randInt(6);
61 const knight1Pos = positions[randIndex];
62 positions.splice(randIndex, 1);
63 randIndex = randInt(5);
64 const knight2Pos = positions[randIndex];
65 positions.splice(randIndex, 1);
66
67 randIndex = randInt(4);
68 const queenPos = positions[randIndex];
69 positions.splice(randIndex, 1);
70
71 const rook1Pos = positions[0];
72 const kingPos = positions[1];
73 const rook2Pos = positions[2];
74
75 pieces[c][rook1Pos] = "r";
76 pieces[c][knight1Pos] = "n";
77 pieces[c][bishop1Pos] = "b";
78 pieces[c][queenPos] = "q";
79 pieces[c][kingPos] = "k";
80 pieces[c][bishop2Pos] = "b";
81 pieces[c][knight2Pos] = "n";
82 pieces[c][rook2Pos] = "r";
83 if (c == 'b') pieces[c] = pieces[c].map(p => piecesMap[p]);
84 else flags = V.CoordToColumn(rook1Pos) + V.CoordToColumn(rook2Pos);
85 }
86 // Add turn + flags + enpassant
87 return (
88 pieces["b"].join("") +
89 "/8/pppppppp/8/8/8/PPPPPPPP/" +
90 pieces["w"].join("").toUpperCase() +
91 " w 0 " + flags + " -"
92 );
93 }
94
95 getFlagsFen() {
96 return this.castleFlags['w'].map(V.CoordToColumn).join("");
97 }
98
99 setFlags(fenflags) {
100 this.castleFlags = { 'w': [-1, -1] };
101 for (let i = 0; i < 2; i++)
102 this.castleFlags['w'][i] = V.ColumnToCoord(fenflags.charAt(i));
103 }
104
105 static get LANCER() {
106 return 'l';
107 }
108 static get ARCHER() {
109 return 'a';
110 }
111 static get KHESHIG() {
112 return 'h';
113 }
114 static get YURT() {
115 return 'y';
116 }
117 // Khan is technically a King, so let's keep things simple.
118
119 static get PIECES() {
120 return ChessRules.PIECES.concat([V.LANCER, V.ARCHER, V.KHESHIG, V.YURT]);
121 }
122
123 getPotentialMovesFrom([x, y]) {
124 switch (this.getPiece(x, y)) {
125 case V.LANCER:
126 return this.getPotentialLancerMoves([x, y]);
127 case V.ARCHER:
128 return this.getPotentialArcherMoves([x, y]);
129 case V.KHESHIG:
130 return this.getPotentialKheshigMoves([x, y]);
131 case V.YURT:
132 return this.getPotentialYurtMoves([x, y]);
133 default:
134 return super.getPotentialMovesFrom([x, y]);
135 }
136 return [];
137 }
138
139 getSlideNJumpMoves([x, y], steps, oneStep, options) {
140 options = options || {};
141 let moves = [];
142 outerLoop: for (let step of steps) {
143 let i = x + step[0];
144 let j = y + step[1];
145 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
146 if (!options.onlyTake) moves.push(this.getBasicMove([x, y], [i, j]));
147 if (!!oneStep) continue outerLoop;
148 i += step[0];
149 j += step[1];
150 }
151 if (V.OnBoard(i, j) && this.canTake([x, y], [i, j]) && !options.onlyMove)
152 moves.push(this.getBasicMove([x, y], [i, j]));
153 }
154 return moves;
155 }
156
157 getPotentialLancerMoves(sq) {
158 const onlyMoves = this.getSlideNJumpMoves(
159 sq,
160 V.steps[V.KNIGHT],
161 "oneStep",
162 { onlyMove: true }
163 );
164 const onlyTakes = this.getSlideNJumpMoves(
165 sq,
166 V.steps[V.ROOK],
167 null,
168 { onlyTake: true }
169 );
170 return onlyMoves.concat(onlyTakes);
171 }
172
173 getPotentialArcherMoves(sq) {
174 const onlyMoves = this.getSlideNJumpMoves(
175 sq,
176 V.steps[V.KNIGHT],
177 "oneStep",
178 { onlyMove: true }
179 );
180 const onlyTakes = this.getSlideNJumpMoves(
181 sq,
182 V.steps[V.BISHOP],
183 null,
184 { onlyTake: true }
185 );
186 return onlyMoves.concat(onlyTakes);
187 }
188
189 getPotentialLancerMoves(sq) {
190 const onlyMoves = this.getSlideNJumpMoves(
191 sq,
192 V.steps[V.KNIGHT],
193 "oneStep",
194 { onlyMove: true }
195 );
196 const onlyTakes = this.getSlideNJumpMoves(
197 sq,
198 V.steps[V.ROOK],
199 null,
200 { onlyTake: true }
201 );
202 return onlyMoves.concat(onlyTakes);
203 }
204
205 getPotentialKheshigMoves(sq) {
206 return this.getSlideNJumpMoves(
207 sq,
208 V.steps[V.KNIGHT].concat(V.steps[V.ROOK]).concat(V.steps[V.BISHOP]),
209 "oneStep"
210 );
211 }
212
213 getPotentialYurtMoves(sq) {
214 return this.getSlideNJumpMoves(
215 sq,
216 V.steps[V.BISHOP].concat([ [1, 0] ]),
217 "oneStep"
218 );
219 }
220
221 getPotentialKingMoves([x, y]) {
222 if (this.getColor(x, y) == 'w') return super.getPotentialKingMoves([x, y]);
223 // Horde doesn't castle:
224 return this.getSlideNJumpMoves(
225 [x, y],
226 V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
227 "oneStep"
228 );
229 }
230
231 isAttacked(sq, color) {
232 if (color == 'w') {
233 return (
234 super.isAttacked(sq, color) ||
235 this.isAttackedByKheshig(sq, color)
236 );
237 }
238 // Horde: only pawn, king and queen (if promotions) in common:
239 return (
240 super.isAttackedByPawn(sq, color) ||
241 this.isAttackedByLancer(sq, color) ||
242 this.isAttackedByKheshig(sq, color) ||
243 this.isAttackedByArcher(sq, color) ||
244 this.isAttackedByYurt(sq, color) ||
245 super.isAttackedByKing(sq, color) ||
246 super.isAttackedByQueen(sq, color)
247 );
248 }
249
250 isAttackedByLancer(sq, color) {
251 return this.isAttackedBySlideNJump(sq, color, V.LANCER, V.steps[V.ROOK]);
252 }
253
254 isAttackedByArcher(sq, color) {
255 return this.isAttackedBySlideNJump(sq, color, V.ARCHER, V.steps[V.BISHOP]);
256 }
257
258 isAttackedByKheshig(sq, color) {
259 return super.isAttackedBySlideNJump(
260 sq,
261 color,
262 V.KHESHIG,
263 V.steps[V.KNIGHT].concat(V.steps[V.ROOK]).concat(V.steps[V.BISHOP]),
264 "oneStep"
265 );
266 }
267
268 isAttackedByYurt(sq, color) {
269 return super.isAttackedBySlideNJump(
270 sq,
271 color,
272 V.YURT,
273 V.steps[V.BISHOP].concat([ [1, 0] ]),
274 "oneStep"
275 );
276 }
277
278 updateCastleFlags(move, piece) {
279 // Only white can castle:
280 const firstRank = 7;
281 if (piece == V.KING && move.appear[0].c == 'w')
282 this.castleFlags['w'] = [8, 8];
283 else if (
284 move.start.x == firstRank &&
285 this.castleFlags['w'].includes(move.start.y)
286 ) {
287 const flagIdx = (move.start.y == this.castleFlags['w'][0] ? 0 : 1);
288 this.castleFlags['w'][flagIdx] = 8;
289 }
290 else if (
291 move.end.x == firstRank &&
292 this.castleFlags['w'].includes(move.end.y)
293 ) {
294 const flagIdx = (move.end.y == this.castleFlags['w'][0] ? 0 : 1);
295 this.castleFlags['w'][flagIdx] = 8;
296 }
297 }
298
299 getCurrentScore() {
300 // Turn has changed:
301 const color = V.GetOppCol(this.turn);
302 const lastRank = (color == 'w' ? 0 : 7);
303 if (this.kingPos[color][0] == lastRank)
304 // The opposing edge is reached!
305 return color == "w" ? "1-0" : "0-1";
306 if (this.atLeastOneMove()) return "*";
307 // Game over
308 const oppCol = this.turn;
309 if (!this.underCheck(oppCol)) return "1/2";
310 return (oppCol == "w" ? "0-1" : "1-0");
311 }
312
313 static get VALUES() {
314 return Object.assign(
315 {},
316 ChessRules.VALUES,
317 {
318 y: 2,
319 a: 4,
320 h: 7,
321 l: 4
322 }
323 );
324 }
325
326 };