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