Adjust Chakart rules
[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 const baseFen = ChessRules.GenRandInitFen(randomness);
41 return (
42 baseFen.substr(0, 8).split('').map(p => piecesMap[p]).join('') +
43 // Skip 3 first rows + black castle flags
44 "/8/pppppppp" + baseFen.substr(19, 31) + " -"
45 );
46 }
47
48 getFlagsFen() {
49 return this.castleFlags['w'].map(V.CoordToColumn).join("");
50 }
51
52 setFlags(fenflags) {
53 this.castleFlags = { 'w': [-1, -1] };
54 for (let i = 0; i < 2; i++)
55 this.castleFlags['w'][i] = V.ColumnToCoord(fenflags.charAt(i));
56 }
57
58 static get LANCER() {
59 return 'l';
60 }
61 static get ARCHER() {
62 return 'a';
63 }
64 static get KHESHIG() {
65 return 'h';
66 }
67 static get YURT() {
68 return 'y';
69 }
70 // Khan is technically a King, so let's keep things simple.
71
72 static get PIECES() {
73 return ChessRules.PIECES.concat([V.LANCER, V.ARCHER, V.KHESHIG, V.YURT]);
74 }
75
76 getPotentialMovesFrom([x, y]) {
77 switch (this.getPiece(x, y)) {
78 case V.LANCER:
79 return this.getPotentialLancerMoves([x, y]);
80 case V.ARCHER:
81 return this.getPotentialArcherMoves([x, y]);
82 case V.KHESHIG:
83 return this.getPotentialKheshigMoves([x, y]);
84 case V.YURT:
85 return this.getPotentialYurtMoves([x, y]);
86 default:
87 return super.getPotentialMovesFrom([x, y]);
88 }
89 return [];
90 }
91
92 getSlideNJumpMoves([x, y], steps, oneStep, options) {
93 options = options || {};
94 let moves = [];
95 outerLoop: for (let step of steps) {
96 let i = x + step[0];
97 let j = y + step[1];
98 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
99 if (!options.onlyTake) moves.push(this.getBasicMove([x, y], [i, j]));
100 if (!!oneStep) continue outerLoop;
101 i += step[0];
102 j += step[1];
103 }
104 if (V.OnBoard(i, j) && this.canTake([x, y], [i, j]) && !options.onlyMove)
105 moves.push(this.getBasicMove([x, y], [i, j]));
106 }
107 return moves;
108 }
109
110 getPotentialLancerMoves(sq) {
111 const onlyMoves = this.getSlideNJumpMoves(
112 sq,
113 V.steps[V.KNIGHT],
114 "oneStep",
115 { onlyMove: true }
116 );
117 const onlyTakes = this.getSlideNJumpMoves(
118 sq,
119 V.steps[V.ROOK],
120 null,
121 { onlyTake: true }
122 );
123 return onlyMoves.concat(onlyTakes);
124 }
125
126 getPotentialArcherMoves(sq) {
127 const onlyMoves = this.getSlideNJumpMoves(
128 sq,
129 V.steps[V.KNIGHT],
130 "oneStep",
131 { onlyMove: true }
132 );
133 const onlyTakes = this.getSlideNJumpMoves(
134 sq,
135 V.steps[V.BISHOP],
136 null,
137 { onlyTake: true }
138 );
139 return onlyMoves.concat(onlyTakes);
140 }
141
142 getPotentialKheshigMoves(sq) {
143 return super.getSlideNJumpMoves(
144 sq,
145 V.steps[V.KNIGHT].concat(V.steps[V.ROOK]).concat(V.steps[V.BISHOP]),
146 "oneStep"
147 );
148 }
149
150 getPotentialYurtMoves(sq) {
151 return super.getSlideNJumpMoves(
152 sq,
153 V.steps[V.BISHOP].concat([ [1, 0] ]),
154 "oneStep"
155 );
156 }
157
158 getPotentialKingMoves([x, y]) {
159 if (this.getColor(x, y) == 'w') return super.getPotentialKingMoves([x, y]);
160 // Horde doesn't castle:
161 return super.getSlideNJumpMoves(
162 [x, y],
163 V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
164 "oneStep"
165 );
166 }
167
168 isAttacked(sq, color) {
169 if (color == 'w') {
170 return (
171 super.isAttacked(sq, color) ||
172 this.isAttackedByKheshig(sq, color)
173 );
174 }
175 // Horde: only pawn, king and queen (if promotions) in common:
176 return (
177 super.isAttackedByPawn(sq, color) ||
178 this.isAttackedByLancer(sq, color) ||
179 this.isAttackedByKheshig(sq, color) ||
180 this.isAttackedByArcher(sq, color) ||
181 this.isAttackedByYurt(sq, color) ||
182 super.isAttackedByKing(sq, color) ||
183 super.isAttackedByQueen(sq, color)
184 );
185 }
186
187 isAttackedByLancer(sq, color) {
188 return this.isAttackedBySlideNJump(sq, color, V.LANCER, V.steps[V.ROOK]);
189 }
190
191 isAttackedByArcher(sq, color) {
192 return this.isAttackedBySlideNJump(sq, color, V.ARCHER, V.steps[V.BISHOP]);
193 }
194
195 isAttackedByKheshig(sq, color) {
196 return super.isAttackedBySlideNJump(
197 sq,
198 color,
199 V.KHESHIG,
200 V.steps[V.KNIGHT].concat(V.steps[V.ROOK]).concat(V.steps[V.BISHOP]),
201 "oneStep"
202 );
203 }
204
205 isAttackedByYurt(sq, color) {
206 return super.isAttackedBySlideNJump(
207 sq,
208 color,
209 V.YURT,
210 V.steps[V.BISHOP].concat([ [1, 0] ]),
211 "oneStep"
212 );
213 }
214
215 updateCastleFlags(move, piece) {
216 // Only white can castle:
217 const firstRank = 7;
218 if (piece == V.KING && move.appear[0].c == 'w')
219 this.castleFlags['w'] = [8, 8];
220 else if (
221 move.start.x == firstRank &&
222 this.castleFlags['w'].includes(move.start.y)
223 ) {
224 const flagIdx = (move.start.y == this.castleFlags['w'][0] ? 0 : 1);
225 this.castleFlags['w'][flagIdx] = 8;
226 }
227 else if (
228 move.end.x == firstRank &&
229 this.castleFlags['w'].includes(move.end.y)
230 ) {
231 const flagIdx = (move.end.y == this.castleFlags['w'][0] ? 0 : 1);
232 this.castleFlags['w'][flagIdx] = 8;
233 }
234 }
235
236 getCurrentScore() {
237 // Turn has changed:
238 const color = V.GetOppCol(this.turn);
239 const lastRank = (color == 'w' ? 0 : 7);
240 if (this.kingPos[color][0] == lastRank)
241 // The opposing edge is reached!
242 return color == "w" ? "1-0" : "0-1";
243 if (this.atLeastOneMove()) return "*";
244 // Game over
245 const oppCol = this.turn;
246 if (!this.underCheck(oppCol)) return "1/2";
247 return (oppCol == "w" ? "0-1" : "1-0");
248 }
249
250 static get VALUES() {
251 return Object.assign(
252 {},
253 ChessRules.VALUES,
254 {
255 y: 2,
256 a: 4,
257 h: 7,
258 l: 4
259 }
260 );
261 }
262
263 };