Commit | Line | Data |
---|---|---|
7e8a7ea1 | 1 | import { ChessRules, Move, PiPo } from "@/base_rules"; |
b0d55a05 BA |
2 | |
3 | export class TitanRules extends ChessRules { | |
7e8a7ea1 BA |
4 | |
5 | static get IMAGE_EXTENSION() { | |
6 | // Temporarily, for the time SVG pieces are being designed: | |
7 | return ".png"; | |
8 | } | |
b0d55a05 | 9 | |
31c53595 | 10 | // Decode if normal piece, or + bishop or knight |
7e8a7ea1 BA |
11 | getPiece(x, y) { |
12 | const piece = this.board[x][y].charAt(1); | |
31c53595 BA |
13 | if (ChessRules.PIECES.includes(piece)) return piece; |
14 | // Augmented piece: | |
15 | switch (piece) { | |
16 | case 'a': | |
17 | case 'c': | |
18 | return 'b'; | |
19 | case 'j': | |
20 | case 'l': | |
21 | return 'k'; | |
22 | case 'm': | |
23 | case 'o': | |
24 | return 'n'; | |
25 | case 's': | |
26 | case 't': | |
27 | return 'q'; | |
28 | case 'u': | |
29 | case 'v': | |
30 | return 'r'; | |
31 | } | |
32 | } | |
33 | ||
b0d55a05 BA |
34 | // Code: a/c = bishop + knight/bishop j/l for king, |
35 | // m/o for knight, s/t for queen, u/v for rook | |
36 | static get AUGMENTED_PIECES() { | |
31c53595 BA |
37 | return [ |
38 | 'a', | |
39 | 'c', | |
40 | 'j', | |
41 | 'l', | |
42 | 'm', | |
43 | 'o', | |
44 | 's', | |
45 | 't', | |
46 | 'u', | |
47 | 'v' | |
48 | ]; | |
b0d55a05 | 49 | } |
31c53595 | 50 | |
7e8a7ea1 BA |
51 | getPpath(b) { |
52 | return "Titan/" + b; | |
53 | } | |
54 | ||
31c53595 | 55 | // Decode above notation into additional piece |
b0d55a05 | 56 | getExtraPiece(symbol) { |
31c53595 BA |
57 | if (['a','j','m','s','u'].includes(symbol)) |
58 | return 'n'; | |
59 | return 'b'; | |
b0d55a05 BA |
60 | } |
61 | ||
7e8a7ea1 BA |
62 | // Inverse operation: augment piece |
63 | getAugmented(piece) { | |
64 | const knight = this.movesCount <= 1; | |
65 | switch (piece) { | |
66 | case V.ROOK: return (knight ? 'u' : 'v'); | |
67 | case V.KNIGHT: return (knight ? 'm' : 'o'); | |
68 | case V.BISHOP: return (knight ? 'a' : 'c'); | |
69 | case V.QUEEN: return (knight ? 's' : 't'); | |
70 | case V.KING: return (knight ? 'j' : 'l'); | |
71 | } | |
72 | return '_'; //never reached | |
73 | } | |
74 | ||
75 | static IsGoodPosition(position) { | |
76 | if (position.length == 0) return false; | |
77 | const rows = position.split("/"); | |
78 | if (rows.length != V.size.x) return false; | |
79 | let kings = { "w": 0, "b": 0 }; | |
80 | const allPiecesCodes = V.PIECES.concat(V.AUGMENTED_PIECES); | |
81 | const kingBlackCodes = ['j','k','l']; | |
82 | const kingWhiteCodes = ['J','K','L']; | |
83 | for (let row of rows) { | |
84 | let sumElts = 0; | |
85 | for (let i = 0; i < row.length; i++) { | |
86 | if (kingBlackCodes.includes(row[i])) kings['b']++; | |
87 | else if (kingWhiteCodes.includes(row[i])) kings['w']++; | |
88 | if (allPiecesCodes.includes(row[i].toLowerCase())) sumElts++; | |
89 | else { | |
90 | const num = parseInt(row[i], 10); | |
91 | if (isNaN(num)) return false; | |
92 | sumElts += num; | |
93 | } | |
94 | } | |
95 | if (sumElts != V.size.y) return false; | |
96 | } | |
97 | // Both kings should be on board, only one of each color: | |
98 | if (Object.values(kings).some(v => v != 1)) return false; | |
99 | return true; | |
100 | } | |
101 | ||
102 | // Kings may be augmented: | |
103 | scanKings(fen) { | |
104 | this.kingPos = { w: [-1, -1], b: [-1, -1] }; | |
105 | const rows = V.ParseFen(fen).position.split("/"); | |
106 | for (let i = 0; i < rows.length; i++) { | |
107 | let k = 0; //column index on board | |
108 | for (let j = 0; j < rows[i].length; j++) { | |
109 | const piece = rows[i].charAt(j); | |
110 | if (['j','k','l'].includes(piece.toLowerCase())) { | |
111 | const color = (piece.charCodeAt(0) <= 90 ? 'w' : 'b'); | |
112 | this.kingPos[color] = [i, k]; | |
113 | } | |
114 | else { | |
115 | const num = parseInt(rows[i].charAt(j), 10); | |
116 | if (!isNaN(num)) k += num - 1; | |
117 | } | |
118 | k++; | |
119 | } | |
120 | } | |
121 | } | |
122 | ||
31c53595 BA |
123 | // If piece not in usual list, bishop or knight appears. |
124 | getPotentialMovesFrom([x, y]) { | |
7e8a7ea1 BA |
125 | if (this.movesCount <= 3) { |
126 | // Setup stage | |
127 | const color = this.getColor(x, y); | |
128 | const firstRank = (color == 'w' ? 7 : 0); | |
129 | if (x != firstRank || V.AUGMENTED_PIECES.includes(this.board[x][y][1])) | |
130 | return []; | |
131 | const piece = this.getPiece(x, y); | |
132 | const move = new Move({ | |
133 | appear: [ | |
134 | new PiPo({ x: x, y: y, c: color, p: this.getAugmented(piece) }) | |
135 | ], | |
136 | vanish: [ | |
137 | new PiPo({ x: x, y: y, c: color, p: piece }) | |
138 | ], | |
139 | start: { x: x, y: y }, | |
140 | end: { x: x, y: y } | |
141 | }); | |
142 | return [move]; | |
143 | } | |
144 | let moves = super.getPotentialMovesFrom([x, y]); | |
145 | const initialPiece = this.getPiece(x, y); | |
b0d55a05 BA |
146 | const color = this.turn; |
147 | if ( | |
3208c667 BA |
148 | ((color == 'w' && x == 7) || (color == "b" && x == 0)) && |
149 | V.AUGMENTED_PIECES.includes(this.board[x][y][1]) | |
b0d55a05 | 150 | ) { |
31c53595 | 151 | const newPiece = this.getExtraPiece(this.board[x][y][1]); |
b0d55a05 | 152 | moves.forEach(m => { |
7e8a7ea1 | 153 | m.appear[0].p = initialPiece; |
b0d55a05 BA |
154 | m.appear.push( |
155 | new PiPo({ | |
156 | p: newPiece, | |
157 | c: color, | |
31c53595 BA |
158 | x: x, |
159 | y: y | |
b0d55a05 BA |
160 | }) |
161 | ); | |
162 | }); | |
3208c667 BA |
163 | moves.forEach(m => { |
164 | if (m.vanish.length <= 1) return; | |
165 | const [vx, vy] = [m.vanish[1].x, m.vanish[1].y]; | |
166 | if ( | |
167 | m.appear.length >= 2 && //3 if the king was also augmented | |
168 | m.vanish.length == 2 && | |
169 | m.vanish[1].c == color && | |
170 | V.AUGMENTED_PIECES.includes(this.board[vx][vy][1]) | |
171 | ) { | |
172 | // Castle, rook is an "augmented piece" | |
173 | m.appear[1].p = V.ROOK; | |
174 | m.appear.push( | |
175 | new PiPo({ | |
176 | p: this.getExtraPiece(this.board[vx][vy][1]), | |
177 | c: color, | |
178 | x: vx, | |
179 | y: vy | |
180 | }) | |
181 | ); | |
182 | } | |
183 | }); | |
b0d55a05 BA |
184 | } |
185 | return moves; | |
186 | } | |
187 | ||
7c05a5f2 | 188 | hoverHighlight([x, y]) { |
0fb43db7 BA |
189 | const c = this.turn; |
190 | return ( | |
191 | this.movesCount <= 3 && | |
192 | ((c == 'w' && x == 7) || (c == 'b' && x == 0)) | |
193 | ); | |
194 | } | |
195 | ||
7e8a7ea1 BA |
196 | // Special case of move 1 = choose squares, knight first, then bishop |
197 | doClick(square) { | |
198 | if (this.movesCount >= 4) return null; | |
199 | const color = this.turn; | |
200 | const [x, y] = [square[0], square[1]]; | |
201 | if ((color == 'w' && x != 7) || (color == 'b' && x != 0)) return null; | |
202 | const selectedPiece = this.board[x][y][1]; | |
203 | return new Move({ | |
204 | appear: [ | |
205 | new PiPo({ | |
206 | x: x, | |
207 | y: y, | |
208 | c: color, | |
209 | p: this.getAugmented(selectedPiece) | |
210 | }) | |
211 | ], | |
212 | vanish: [ | |
213 | new PiPo({ | |
214 | x: x, | |
215 | y: y, | |
216 | c: color, | |
217 | p: selectedPiece | |
218 | }) | |
219 | ], | |
220 | start: { x: x, y: y }, | |
221 | end: { x: x, y: y } | |
222 | }); | |
223 | } | |
224 | ||
225 | postPlay(move) { | |
226 | if (this.movesCount > 4) super.postPlay(move); | |
227 | } | |
228 | ||
229 | postUndo(move) { | |
230 | if (this.movesCount >= 4) super.postUndo(move); | |
231 | } | |
232 | ||
233 | evalPosition() { | |
234 | let evaluation = 0; | |
235 | for (let i = 0; i < V.size.x; i++) { | |
236 | for (let j = 0; j < V.size.y; j++) { | |
237 | if (this.board[i][j] != V.EMPTY) { | |
238 | const sign = this.getColor(i, j) == "w" ? 1 : -1; | |
239 | const piece = this.getPiece(i, j); | |
240 | evaluation += sign * V.VALUES[piece]; | |
241 | const symbol = this.board[i][j][1]; | |
242 | if (V.AUGMENTED_PIECES.includes(symbol)) { | |
243 | const extraPiece = this.getExtraPiece(symbol); | |
244 | evaluation += sign * V.VALUES[extraPiece] | |
245 | } | |
246 | } | |
247 | } | |
248 | } | |
249 | return evaluation; | |
250 | } | |
251 | ||
252 | getNotation(move) { | |
253 | if ( | |
254 | move.appear[0].x != move.vanish[0].x || | |
255 | move.appear[0].y != move.vanish[0].y | |
256 | ) { | |
257 | if ( | |
258 | V.AUGMENTED_PIECES.includes(move.vanish[0].p) || | |
259 | ( | |
260 | move.vanish.length >= 2 && | |
261 | V.AUGMENTED_PIECES.includes(move.vanish[1].p) | |
262 | ) | |
263 | ) { | |
264 | // Simplify move before calling super.getNotation() | |
265 | let smove = JSON.parse(JSON.stringify(move)); | |
266 | if (ChessRules.PIECES.includes(move.vanish[0].p)) { | |
267 | // Castle with an augmented rook | |
268 | smove.appear.pop(); | |
269 | smove.vanish[1].p = smove.appear[1].p; | |
270 | } | |
271 | else { | |
272 | // Moving an augmented piece | |
273 | smove.appear.pop(); | |
274 | smove.vanish[0].p = smove.appear[0].p; | |
275 | if ( | |
276 | smove.vanish.length == 2 && | |
277 | smove.vanish[0].c == smove.vanish[1].c && | |
278 | V.AUGMENTED_PIECES.includes(move.vanish[1].p) | |
279 | ) { | |
280 | // Castle with an augmented rook | |
281 | smove.appear.pop(); | |
282 | smove.vanish[1].p = smove.appear[1].p; | |
283 | } | |
284 | } | |
285 | return super.getNotation(smove); | |
286 | } | |
287 | // Else, more common case: | |
288 | return super.getNotation(move); | |
289 | } | |
290 | // First moves in game, placements: | |
291 | const square = V.CoordsToSquare(move.appear[0]); | |
292 | const reserve = | |
293 | (['a','j','m','s','u'].includes(move.appear[0].p) ? 'N' : 'B'); | |
294 | return '+' + reserve + '@' + square; | |
295 | } | |
296 | ||
b0d55a05 | 297 | }; |