1 import { ChessRules
, PiPo
, Move
} from "@/base_rules";
2 import { ArrayFun
} from "@/utils/array";
3 import { randInt
} from "@/utils/alea";
5 export class HiddenRules
extends ChessRules
{
6 static get HasFlags() {
10 static get HasCastle() {
14 static get HasEnpassant() {
18 // Analyse in Hidden mode makes no sense
19 static get CanAnalyze() {
23 // Moves are revealed only when game ends, but are highlighted on board
24 static get ShowMoves() {
28 static get HIDDEN_DECODE() {
38 static get HIDDEN_CODE() {
49 // Turn a hidden piece or revealed piece into revealed piece:
51 if (Object
.keys(V
.HIDDEN_DECODE
).includes(p
))
52 return V
.HIDDEN_DECODE
[p
];
57 return ChessRules
.PIECES
.concat(Object
.values(V
.HIDDEN_CODE
));
60 // Pieces can be hidden :)
62 const piece
= this.board
[i
][j
].charAt(1);
63 if (Object
.keys(V
.HIDDEN_DECODE
).includes(piece
))
64 return V
.HIDDEN_DECODE
[piece
];
68 getPpath(b
, color
, score
) {
69 if (Object
.keys(V
.HIDDEN_DECODE
).includes(b
[1])) {
70 // Supposed to be hidden.
71 if (score
== "*" && (!color
|| color
!= b
[0]))
72 return "Hidden/" + b
[0] + "p";
73 // Else: condition OK to show the piece
74 return b
[0] + V
.HIDDEN_DECODE
[b
[1]];
76 // The piece is already not supposed to be hidden:
80 // Scan board for kings positions (no castling)
82 this.kingPos
= { w: [-1, -1], b: [-1, -1] };
83 const fenRows
= V
.ParseFen(fen
).position
.split("/");
84 for (let i
= 0; i
< fenRows
.length
; i
++) {
85 let k
= 0; //column index on board
86 for (let j
= 0; j
< fenRows
[i
].length
; j
++) {
87 switch (fenRows
[i
].charAt(j
)) {
90 this.kingPos
["b"] = [i
, k
];
94 this.kingPos
["w"] = [i
, k
];
97 const num
= parseInt(fenRows
[i
].charAt(j
));
98 if (!isNaN(num
)) k
+= num
- 1;
106 getBasicMove([sx
, sy
], [ex
, ey
], tr
) {
109 Object
.keys(V
.HIDDEN_DECODE
).includes(this.board
[sx
][sy
].charAt(1))
111 // The transformed piece is a priori hidden
112 tr
.p
= V
.HIDDEN_CODE
[tr
.p
];
119 c: tr
? tr
.c : this.getColor(sx
, sy
),
120 p: tr
? tr
.p : this.board
[sx
][sy
].charAt(1)
127 c: this.getColor(sx
, sy
),
128 p: this.board
[sx
][sy
].charAt(1)
133 // The opponent piece disappears if we take it
134 if (this.board
[ex
][ey
] != V
.EMPTY
) {
139 c: this.getColor(ex
, ey
),
140 p: this.board
[ex
][ey
].charAt(1)
143 // Pieces are revealed when they capture
144 mv
.appear
[0].p
= V
.Decode(mv
.appear
[0].p
);
154 // Ignore randomness here: placement is always random asymmetric
155 static GenRandInitFen() {
156 let pieces
= { w: new Array(8), b: new Array(8) };
157 // Shuffle pieces + pawns on two first ranks
158 for (let c
of ["w", "b"]) {
159 let positions
= ArrayFun
.range(16);
161 // Get random squares for bishops
162 let randIndex
= 2 * randInt(8);
163 const bishop1Pos
= positions
[randIndex
];
164 // The second bishop must be on a square of different color
165 let randIndex_tmp
= 2 * randInt(8) + 1;
166 const bishop2Pos
= positions
[randIndex_tmp
];
167 // Remove chosen squares
168 positions
.splice(Math
.max(randIndex
, randIndex_tmp
), 1);
169 positions
.splice(Math
.min(randIndex
, randIndex_tmp
), 1);
171 // Get random squares for knights
172 randIndex
= randInt(14);
173 const knight1Pos
= positions
[randIndex
];
174 positions
.splice(randIndex
, 1);
175 randIndex
= randInt(13);
176 const knight2Pos
= positions
[randIndex
];
177 positions
.splice(randIndex
, 1);
179 // Get random squares for rooks
180 randIndex
= randInt(12);
181 const rook1Pos
= positions
[randIndex
];
182 positions
.splice(randIndex
, 1);
183 randIndex
= randInt(11);
184 const rook2Pos
= positions
[randIndex
];
185 positions
.splice(randIndex
, 1);
187 // Get random square for queen
188 randIndex
= randInt(10);
189 const queenPos
= positions
[randIndex
];
190 positions
.splice(randIndex
, 1);
192 // Get random square for king
193 randIndex
= randInt(9);
194 const kingPos
= positions
[randIndex
];
195 positions
.splice(randIndex
, 1);
197 // Pawns position are all remaining slots:
198 for (let p
of positions
)
201 // Finally put the shuffled pieces in the board array
202 pieces
[c
][rook1Pos
] = "u";
203 pieces
[c
][knight1Pos
] = "o";
204 pieces
[c
][bishop1Pos
] = "c";
205 pieces
[c
][queenPos
] = "t";
206 pieces
[c
][kingPos
] = "l";
207 pieces
[c
][bishop2Pos
] = "c";
208 pieces
[c
][knight2Pos
] = "o";
209 pieces
[c
][rook2Pos
] = "u";
211 let upFen
= pieces
["b"].join("");
212 upFen
= upFen
.substr(0,8) + "/" + upFen
.substr(8).split("").reverse().join("");
213 let downFen
= pieces
["b"].join("").toUpperCase();
214 downFen
= downFen
.substr(0,8) + "/" + downFen
.substr(8).split("").reverse().join("");
215 return upFen
+ "/8/8/8/8/" + downFen
+ " w 0";
223 super.postPlay(move);
225 move.vanish
.length
>= 2 &&
226 [V
.KING
,V
.HIDDEN_CODE
[V
.KING
]].includes(move.vanish
[1].p
)
228 // We took opponent king
229 this.kingPos
[this.turn
] = [-1, -1];
234 super.postUndo(move);
235 const c
= move.vanish
[0].c
;
236 const oppCol
= V
.GetOppCol(c
);
237 if (this.kingPos
[oppCol
][0] < 0)
238 // Last move took opponent's king:
239 this.kingPos
[oppCol
] = [move.vanish
[1].x
, move.vanish
[1].y
];
243 const color
= this.turn
;
244 const kp
= this.kingPos
[color
];
247 return color
== "w" ? "0-1" : "1-0";
248 // Assume that stalemate is impossible:
253 const color
= this.turn
;
254 let moves
= this.getAllValidMoves();
255 for (let move of moves
) {
256 move.eval
= 0; //a priori...
258 // Can I take something ? If yes, do it with some probability
259 if (move.vanish
.length
== 2 && move.vanish
[1].c
!= color
) {
260 // OK this isn't a castling move
261 const myPieceVal
= V
.VALUES
[move.appear
[0].p
];
262 const hisPieceVal
= Object
.keys(V
.HIDDEN_DECODE
).includes(move.vanish
[1].p
)
264 : V
.VALUES
[move.vanish
[1].p
];
266 // Opponent's piece is unknown: do not take too much risk
267 move.eval
= -myPieceVal
+ 1.5; //so that pawns always take
270 else if (myPieceVal
<= hisPieceVal
)
271 move.eval
= hisPieceVal
- myPieceVal
+ 1;
273 // Taking a pawn with minor piece,
274 // or minor piece or pawn with a rook,
275 // or anything but a queen with a queen,
276 // or anything with a king.
277 move.eval
= hisPieceVal
- myPieceVal
;
280 // If no capture, favor small step moves,
281 // but sometimes move the knight anyway
282 const penalty
= V
.Decode(move.vanish
[0].p
) != V
.KNIGHT
283 ? Math
.abs(move.end
.x
- move.start
.x
) + Math
.abs(move.end
.y
- move.start
.y
)
284 : (Math
.random() < 0.5 ? 3 : 1);
285 move.eval
-= penalty
/ (V
.size
.x
+ V
.size
.y
- 1);
288 // TODO: also favor movements toward the center?
291 moves
.sort((a
, b
) => b
.eval
- a
.eval
);
292 let candidates
= [0];
293 for (let j
= 1; j
< moves
.length
&& moves
[j
].eval
== moves
[0].eval
; j
++)
295 return moves
[candidates
[randInt(candidates
.length
)]];
299 // Translate final square
300 const finalSquare
= V
.CoordsToSquare(move.end
);
302 const piece
= this.getPiece(move.start
.x
, move.start
.y
);
303 if (piece
== V
.PAWN
) {
306 if (move.vanish
.length
> move.appear
.length
) {
308 const startColumn
= V
.CoordToColumn(move.start
.y
);
309 notation
= startColumn
+ "x" + finalSquare
;
311 else notation
= finalSquare
;
312 if (move.appear
.length
> 0 && !["p","s"].includes(move.appear
[0].p
)) {
314 const appearPiece
= V
.Decode(move.appear
[0].p
);
315 notation
+= "=" + appearPiece
.toUpperCase();
321 piece
.toUpperCase() +
322 (move.vanish
.length
> move.appear
.length
? "x" : "") +