Adjust Chakart rules
[vchess.git] / client / src / variants / Alapo.js
1 import { ChessRules } from "@/base_rules";
2 import { ArrayFun } from "@/utils/array";
3 import { randInt } from "@/utils/alea";
4
5 export class AlapoRules extends ChessRules {
6
7 static get HasFlags() {
8 return false;
9 }
10
11 static get HasEnpassant() {
12 return false;
13 }
14
15 static get Lines() {
16 return [
17 [[1, 0], [1, 6]],
18 [[5, 0], [5, 6]]
19 ];
20 }
21
22 static get PIECES() {
23 return [V.ROOK, V.BISHOP, V.QUEEN, V.ROOK_S, V.BISHOP_S, V.QUEEN_S];
24 }
25
26 static get ROOK_S() {
27 return "t";
28 }
29 static get BISHOP_S() {
30 return "c";
31 }
32 static get QUEEN_S() {
33 return "s";
34 }
35
36 getPotentialMinirookMoves(sq) {
37 return super.getSlideNJumpMoves(sq, V.steps[V.ROOK], "oneStep");
38 }
39 getPotentialMinibishopMoves(sq) {
40 return super.getSlideNJumpMoves(sq, V.steps[V.BISHOP], "oneStep");
41 }
42 getPotentialMiniqueenMoves(sq) {
43 return (
44 super.getSlideNJumpMoves(
45 sq, V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep")
46 );
47 }
48
49 getPotentialMovesFrom(sq) {
50 switch (this.getPiece(sq[0], sq[1])) {
51 case V.ROOK: return super.getPotentialRookMoves(sq);
52 case V.BISHOP: return super.getPotentialBishopMoves(sq);
53 case V.QUEEN: return super.getPotentialQueenMoves(sq);
54 case V.ROOK_S: return this.getPotentialMinirookMoves(sq);
55 case V.BISHOP_S: return this.getPotentialMinibishopMoves(sq);
56 case V.QUEEN_S: return this.getPotentialMiniqueenMoves(sq);
57 }
58 return [];
59 }
60
61 static get size() {
62 return { x: 6, y: 6 };
63 }
64
65 getPpath(b, color, score, orientation) {
66 // 'i' for "inversed":
67 const suffix = (b[0] == orientation ? "" : "i");
68 return "Alapo/" + b + suffix;
69 }
70
71 static GenRandInitFen(randomness) {
72 if (randomness == 0)
73 return "rbqqbr/tcssct/6/6/TCSSCT/RBQQBR w 0";
74
75 const piece2pawn = {
76 r: 't',
77 q: 's',
78 b: 'c'
79 };
80
81 let pieces = { w: new Array(6), b: new Array(6) };
82 // Shuffle pieces on first (and last rank if randomness == 2)
83 for (let c of ["w", "b"]) {
84 if (c == 'b' && randomness == 1) {
85 pieces['b'] = pieces['w'];
86 break;
87 }
88
89 let positions = ArrayFun.range(6);
90
91 // Get random squares for bishops
92 let randIndex = 2 * randInt(3);
93 const bishop1Pos = positions[randIndex];
94 let randIndex_tmp = 2 * randInt(3) + 1;
95 const bishop2Pos = positions[randIndex_tmp];
96 positions.splice(Math.max(randIndex, randIndex_tmp), 1);
97 positions.splice(Math.min(randIndex, randIndex_tmp), 1);
98
99 // Get random square for queens
100 randIndex = randInt(4);
101 const queen1Pos = positions[randIndex];
102 positions.splice(randIndex, 1);
103 randIndex = randInt(3);
104 const queen2Pos = positions[randIndex];
105 positions.splice(randIndex, 1);
106
107 // Rooks positions are now fixed,
108 const rook1Pos = positions[0];
109 const rook2Pos = positions[1];
110
111 pieces[c][rook1Pos] = "r";
112 pieces[c][bishop1Pos] = "b";
113 pieces[c][queen1Pos] = "q";
114 pieces[c][queen2Pos] = "q";
115 pieces[c][bishop2Pos] = "b";
116 pieces[c][rook2Pos] = "r";
117 }
118
119 return (
120 pieces["b"].join("") + "/" +
121 pieces["b"].map(p => piece2pawn[p]).join("") +
122 "/6/6/" +
123 pieces["w"].map(p => piece2pawn[p].toUpperCase()).join("") + "/" +
124 pieces["w"].join("").toUpperCase() +
125 " w 0"
126 );
127 }
128
129 static IsGoodPosition(position) {
130 if (position.length == 0) return false;
131 const rows = position.split("/");
132 if (rows.length != V.size.x) return false;
133 // Just check that at least one piece of each color is there:
134 let pieces = { "w": 0, "b": 0 };
135 for (let row of rows) {
136 let sumElts = 0;
137 for (let i = 0; i < row.length; i++) {
138 const lowerRi = row[i].toLowerCase();
139 if (V.PIECES.includes(lowerRi)) {
140 pieces[row[i] == lowerRi ? "b" : "w"]++;
141 sumElts++;
142 }
143 else {
144 const num = parseInt(row[i], 10);
145 if (isNaN(num)) return false;
146 sumElts += num;
147 }
148 }
149 if (sumElts != V.size.y) return false;
150 }
151 if (Object.values(pieces).some(v => v == 0)) return false;
152 return true;
153 }
154
155 // Find possible captures by opponent on [x, y]
156 findCaptures([x, y]) {
157 const color = this.getColor(x, y);
158 let moves = [];
159 const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
160 const oppCol = V.GetOppCol(color);
161 for (let loop = 0; loop < steps.length; loop++) {
162 const step = steps[loop];
163 let i = x + step[0];
164 let j = y + step[1];
165 let stepsAfter = 1;
166 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
167 i += step[0];
168 j += step[1];
169 stepsAfter++;
170 }
171 if (
172 V.OnBoard(i, j) &&
173 this.board[i][j] != V.EMPTY &&
174 this.getColor(i, j) == oppCol
175 ) {
176 const oppPiece = this.getPiece(i, j);
177 if (
178 (
179 stepsAfter >= 2 &&
180 [V.ROOK_S, V.BISHOP_S, V.QUEEN_S].includes(oppPiece)
181 )
182 ||
183 (
184 [V.BISHOP, V.BISHOP_S].includes(oppPiece) &&
185 step.some(e => e == 0)
186 )
187 ||
188 (
189 [V.ROOK, V.ROOK_S].includes(oppPiece) &&
190 step.every(e => e != 0)
191 )
192 ) {
193 continue;
194 }
195 return true;
196 }
197 }
198 return false;
199 }
200
201 postPlay() {}
202 postUndo() {}
203
204 getCheckSquares() {
205 return [];
206 }
207 filterValid(moves) {
208 return moves;
209 }
210
211 getCurrentScore() {
212 // Try both colors (to detect potential suicides)
213 for (let c of ['w', 'b']) {
214 const oppCol = V.GetOppCol(c);
215 const goal = (c == 'w' ? 0 : 5);
216 if (
217 this.board[goal].some(
218 (b,j) => b[0] == c && !this.findCaptures([goal, j])
219 )
220 ) {
221 return c == 'w' ? "1-0" : "0-1";
222 }
223 }
224 return super.getCurrentScore();
225 }
226
227 static get VALUES() {
228 return {
229 r: 5,
230 b: 3,
231 q: 9,
232 t: 3,
233 c: 2,
234 s: 5
235 };
236 }
237
238 };