Commit | Line | Data |
---|---|---|
0ba6420d BA |
1 | import { ChessRules } from "@/base_rules"; |
2 | import { ArrayFun } from "@/utils/array"; | |
3 | import { randInt, shuffle } from "@/utils/alea"; | |
4 | ||
5 | export const VariantRules = class RoyalraceRules extends ChessRules { | |
6 | static get HasFlags() { | |
7 | return false; | |
8 | } | |
9 | ||
10 | static get HasEnpassant() { | |
11 | return false; | |
12 | } | |
13 | ||
14 | static get CanFlip() { | |
15 | return false; | |
16 | } | |
17 | ||
18 | static get size() { | |
19 | return { x: 11, y: 11 }; | |
20 | } | |
21 | ||
7ba4a5bc BA |
22 | static GenRandInitFen(randomness) { |
23 | if (!randomness) randomness = 2; | |
24 | if (randomness == 0) | |
25 | return "11/11/11/11/11/11/11/11/11/QRBNP1pnbrq/KRBNP1pnbrk w 0"; | |
26 | ||
0ba6420d BA |
27 | let pieces = { w: new Array(10), b: new Array(10) }; |
28 | // Shuffle pieces on first and second rank | |
29 | for (let c of ["w", "b"]) { | |
7ba4a5bc BA |
30 | if (c == 'b' && randomness == 1) { |
31 | pieces['b'] = JSON.parse(JSON.stringify(pieces['w'])).reverse(); | |
32 | pieces['b'] = | |
33 | pieces['b'].splice(5,10).reverse().concat( | |
34 | pieces['b'].splice(0,5).reverse()); | |
35 | break; | |
36 | } | |
37 | ||
0ba6420d BA |
38 | // Reserve 4 and 5 which are pawns positions |
39 | let positions = ArrayFun.range(10).filter(i => i != 4 && i != 5); | |
40 | ||
41 | // Get random squares for bishops | |
42 | let randIndex = 2 * randInt(4); | |
43 | const bishop1Pos = positions[randIndex]; | |
44 | // The second bishop must be on a square of different color | |
45 | let randIndex_tmp = 2 * randInt(4) + 1; | |
46 | const bishop2Pos = positions[randIndex_tmp]; | |
47 | // Remove chosen squares | |
48 | positions.splice(Math.max(randIndex, randIndex_tmp), 1); | |
49 | positions.splice(Math.min(randIndex, randIndex_tmp), 1); | |
50 | ||
51 | // Place the king at random on (remaining squares of) first row | |
52 | let maxIndex = 4; | |
53 | if (positions[maxIndex-1] >= 4) | |
54 | maxIndex--; | |
55 | if (positions[maxIndex-1] >= 4) | |
56 | maxIndex--; | |
57 | randIndex = randInt(maxIndex); | |
58 | const kingPos = positions[randIndex]; | |
59 | positions.splice(randIndex, 1); | |
60 | ||
61 | // Get random squares for knights | |
62 | randIndex = randInt(5); | |
63 | const knight1Pos = positions[randIndex]; | |
64 | positions.splice(randIndex, 1); | |
65 | randIndex = randInt(4); | |
66 | const knight2Pos = positions[randIndex]; | |
67 | positions.splice(randIndex, 1); | |
68 | ||
69 | // Get random squares for rooks | |
70 | randIndex = randInt(3); | |
71 | const rook1Pos = positions[randIndex]; | |
72 | positions.splice(randIndex, 1); | |
73 | randIndex = randInt(2); | |
74 | const rook2Pos = positions[randIndex]; | |
75 | positions.splice(randIndex, 1); | |
76 | ||
77 | // Queen position is now determined, | |
78 | // because pawns are not placed at random | |
79 | const queenPos = positions[0]; | |
80 | ||
81 | // Finally put the shuffled pieces in the board array | |
82 | pieces[c][rook1Pos] = "r"; | |
83 | pieces[c][knight1Pos] = "n"; | |
84 | pieces[c][bishop1Pos] = "b"; | |
85 | pieces[c][queenPos] = "q"; | |
86 | pieces[c][kingPos] = "k"; | |
87 | pieces[c][bishop2Pos] = "b"; | |
88 | pieces[c][knight2Pos] = "n"; | |
89 | pieces[c][rook2Pos] = "r"; | |
90 | pieces[c][4] = "p"; | |
91 | pieces[c][5] = "p"; | |
92 | } | |
93 | const whiteFen = pieces["w"].join("").toUpperCase(); | |
94 | const blackFen = pieces["b"].join(""); | |
95 | return ( | |
96 | "11/11/11/11/11/11/11/11/11/" + | |
97 | whiteFen.substr(5).split("").reverse().join("") + | |
98 | "1" + | |
f446ee64 | 99 | blackFen.substr(5).split("").join("") + |
0ba6420d | 100 | "/" + |
f446ee64 BA |
101 | whiteFen.substr(0,5) + |
102 | "1" + | |
103 | blackFen.substr(0,5).split("").reverse().join("") + | |
0ba6420d BA |
104 | " w 0" |
105 | ); | |
106 | } | |
107 | ||
108 | getPotentialPawnMoves([x, y]) { | |
109 | // Normal moves (as a rook) | |
110 | let moves = | |
111 | this.getSlideNJumpMoves([x, y], V.steps[V.ROOK]).filter(m => { | |
112 | // Remove captures. Alt: redefine canTake | |
113 | return m.vanish.length == 1; | |
114 | }); | |
115 | ||
f446ee64 BA |
116 | // Captures (in both directions) |
117 | for (let shiftX of [-1, 1]) { | |
118 | for (let shiftY of [-1, 1]) { | |
119 | if ( | |
120 | V.OnBoard(x + shiftX, y + shiftY) && | |
121 | this.board[x + shiftX][y + shiftY] != V.EMPTY && | |
122 | this.canTake([x, y], [x + shiftX, y + shiftY]) | |
123 | ) { | |
124 | moves.push(this.getBasicMove([x, y], [x + shiftX, y + shiftY])); | |
125 | } | |
0ba6420d BA |
126 | } |
127 | } | |
128 | ||
129 | return moves; | |
130 | } | |
131 | ||
132 | getPotentialKnightMoves(sq) { | |
133 | // Knight becomes knightrider: | |
134 | return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT]); | |
135 | } | |
136 | ||
137 | // What are the king moves from square x,y ? | |
138 | getPotentialKingMoves(sq) { | |
139 | return this.getSlideNJumpMoves( | |
140 | sq, | |
141 | V.steps[V.ROOK].concat(V.steps[V.BISHOP]), | |
142 | "oneStep" | |
143 | ); | |
144 | } | |
145 | ||
146 | filterValid(moves) { | |
147 | if (moves.length == 0) return []; | |
148 | const color = this.turn; | |
149 | const oppCol = V.GetOppCol(color); | |
150 | return moves.filter(m => { | |
151 | this.play(m); | |
152 | // Giving check is forbidden as well: | |
153 | const res = !this.underCheck(color) && !this.underCheck(oppCol); | |
154 | this.undo(m); | |
155 | return res; | |
156 | }); | |
157 | } | |
158 | ||
159 | isAttackedByPawn([x, y], colors) { | |
160 | const pawnShift = 1; | |
161 | if (x + pawnShift < V.size.x) { | |
162 | for (let c of colors) { | |
163 | for (let i of [-1, 1]) { | |
164 | if ( | |
165 | y + i >= 0 && | |
166 | y + i < V.size.y && | |
167 | this.getPiece(x + pawnShift, y + i) == V.PAWN && | |
168 | this.getColor(x + pawnShift, y + i) == c | |
169 | ) { | |
170 | return true; | |
171 | } | |
172 | } | |
173 | } | |
174 | } | |
175 | return false; | |
176 | } | |
177 | ||
178 | isAttackedByKnight(sq, colors) { | |
179 | return this.isAttackedBySlideNJump( | |
180 | sq, | |
181 | colors, | |
182 | V.KNIGHT, | |
183 | V.steps[V.KNIGHT] | |
184 | ); | |
185 | } | |
186 | ||
187 | getCurrentScore() { | |
188 | // Turn has changed: | |
189 | const color = V.GetOppCol(this.turn); | |
190 | if (this.kingPos[color][0] == 0) | |
191 | // The opposing edge is reached! | |
192 | return color == "w" ? "1-0" : "0-1"; | |
c3a86f01 BA |
193 | if (this.atLeastOneMove()) |
194 | return "*"; | |
195 | // Stalemate (will probably never happen) | |
196 | return "1/2"; | |
0ba6420d BA |
197 | } |
198 | ||
199 | static get SEARCH_DEPTH() { | |
200 | return 2; | |
201 | } | |
202 | ||
203 | static get VALUES() { | |
204 | return { | |
205 | p: 2, | |
206 | r: 5, | |
207 | n: 3, | |
208 | b: 3, | |
209 | q: 9, | |
210 | k: 1000 | |
211 | }; | |
212 | } | |
213 | ||
214 | evalPosition() { | |
215 | // Count material: | |
216 | let evaluation = super.evalPosition(); | |
217 | // Ponder with king position: | |
218 | return evaluation/5 + this.kingPos["b"][0] - this.kingPos["w"][0]; | |
219 | } | |
220 | ||
221 | getNotation(move) { | |
222 | // Since pawns are much more mobile, treat them as other pieces: | |
223 | return ( | |
224 | move.vanish[0].p.toUpperCase() + | |
225 | (move.vanish.length > move.appear.length ? "x" : "") + | |
226 | V.CoordsToSquare(move.end) | |
227 | ); | |
228 | } | |
229 | }; |