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