Commit | Line | Data |
---|---|---|
c7550017 BA |
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 { | |
7e8a7ea1 | 6 | |
c7550017 BA |
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 | ||
1269441e | 40 | const baseFen = ChessRules.GenRandInitFen(randomness); |
c7550017 | 41 | return ( |
1269441e BA |
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) + " -" | |
c7550017 BA |
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])); | |
0b8bd121 | 100 | if (!!oneStep) continue outerLoop; |
c7550017 BA |
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 | ||
c7550017 | 142 | getPotentialKheshigMoves(sq) { |
1269441e | 143 | return super.getSlideNJumpMoves( |
c7550017 BA |
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) { | |
1269441e | 151 | return super.getSlideNJumpMoves( |
c7550017 | 152 | sq, |
79e05a1a BA |
153 | V.steps[V.BISHOP].concat([ [1, 0] ]), |
154 | "oneStep" | |
c7550017 BA |
155 | ); |
156 | } | |
157 | ||
158 | getPotentialKingMoves([x, y]) { | |
159 | if (this.getColor(x, y) == 'w') return super.getPotentialKingMoves([x, y]); | |
160 | // Horde doesn't castle: | |
1269441e | 161 | return super.getSlideNJumpMoves( |
c7550017 BA |
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 | } | |
6c7cbfed | 175 | // Horde: only pawn, king and queen (if promotions) in common: |
c7550017 BA |
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) || | |
6c7cbfed | 182 | super.isAttackedByKing(sq, color) || |
c7550017 BA |
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, | |
79e05a1a | 210 | V.steps[V.BISHOP].concat([ [1, 0] ]), |
c7550017 BA |
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 | } | |
7e8a7ea1 | 262 | |
c7550017 | 263 | }; |