1 import { ChessRules
} from "@/base_rules";
2 import { ArrayFun
} from "@/utils/array";
3 import { randInt
} from "@/utils/alea";
5 export const VariantRules
= class DarkRules
extends ChessRules
{
6 // Analyse in Dark mode makes no sense
7 static get CanAnalyze() {
11 // Moves are revealed only when game ends
12 static get ShowMoves() {
16 setOtherVariables(fen
) {
17 super.setOtherVariables(fen
);
18 const [sizeX
, sizeY
] = [V
.size
.x
, V
.size
.y
];
20 w: ArrayFun
.init(sizeX
, sizeY
),
21 b: ArrayFun
.init(sizeX
, sizeY
)
23 // Setup enlightened: squares reachable by each side
24 // (TODO: one side would be enough ?)
25 this.updateEnlightened();
29 for (let i
= 0; i
< V
.size
.x
; i
++) {
30 for (let j
= 0; j
< V
.size
.y
; j
++) {
31 this.enlightened
["w"][i
][j
] = false;
32 this.enlightened
["b"][i
][j
] = false;
35 const pawnShift
= { w: -1, b: 1 };
36 // Initialize with pieces positions (which are seen)
37 for (let i
= 0; i
< V
.size
.x
; i
++) {
38 for (let j
= 0; j
< V
.size
.y
; j
++) {
39 if (this.board
[i
][j
] != V
.EMPTY
) {
40 const color
= this.getColor(i
, j
);
41 this.enlightened
[color
][i
][j
] = true;
42 // Add potential squares visible by "impossible pawn capture"
43 if (this.getPiece(i
, j
) == V
.PAWN
) {
44 for (let shiftY
of [-1, 1]) {
46 V
.OnBoard(i
+ pawnShift
[color
], j
+ shiftY
) &&
47 this.board
[i
+ pawnShift
[color
]][j
+ shiftY
] == V
.EMPTY
49 this.enlightened
[color
][i
+ pawnShift
[color
]][j
+ shiftY
] = true;
56 const currentTurn
= this.turn
;
58 const movesWhite
= this.getAllValidMoves();
60 const movesBlack
= this.getAllValidMoves();
61 this.turn
= currentTurn
;
62 for (let move of movesWhite
)
63 this.enlightened
["w"][move.end
.x
][move.end
.y
] = true;
64 for (let move of movesBlack
)
65 this.enlightened
["b"][move.end
.x
][move.end
.y
] = true;
66 // Include en-passant capturing square if any:
67 let moves
= currentTurn
== "w" ? movesWhite : movesBlack
;
68 for (let m
of moves
) {
70 m
.appear
[0].p
== V
.PAWN
&&
71 m
.vanish
.length
== 2 &&
72 m
.vanish
[1].x
!= m
.end
.x
74 const psq
= m
.vanish
[1];
75 this.enlightened
[currentTurn
][psq
.x
][psq
.y
] = true;
81 // Has to be redefined to avoid an infinite loop
83 const color
= this.turn
;
84 let potentialMoves
= [];
85 for (let i
= 0; i
< V
.size
.x
; i
++) {
86 for (let j
= 0; j
< V
.size
.y
; j
++) {
87 if (this.board
[i
][j
] != V
.EMPTY
&& this.getColor(i
, j
) == color
)
88 Array
.prototype.push
.apply(
90 this.getPotentialMovesFrom([i
, j
])
94 return potentialMoves
; //because there are no checks
101 updateVariables(move) {
102 super.updateVariables(move);
103 if (move.vanish
.length
>= 2 && move.vanish
[1].p
== V
.KING
)
104 // We took opponent king (because if castle vanish[1] is a rook)
105 this.kingPos
[this.turn
] = [-1, -1];
107 // Update lights for both colors:
108 this.updateEnlightened();
111 unupdateVariables(move) {
112 super.unupdateVariables(move);
113 const c
= move.vanish
[0].c
;
114 const oppCol
= V
.GetOppCol(c
);
115 if (this.kingPos
[oppCol
][0] < 0)
116 // Last move took opponent's king:
117 this.kingPos
[oppCol
] = [move.vanish
[1].x
, move.vanish
[1].y
];
119 // Update lights for both colors:
120 this.updateEnlightened();
124 const color
= this.turn
;
125 const kp
= this.kingPos
[color
];
128 return color
== "w" ? "0-1" : "1-0";
129 // Assume that stalemate is impossible (I think so. Would need proof...)
133 static get THRESHOLD_MATE() {
134 return 500; //checkmates evals may be slightly below 1000
137 // In this special situation, we just look 1 half move ahead
139 const maxeval
= V
.INFINITY
;
140 const color
= this.turn
;
141 const oppCol
= V
.GetOppCol(color
);
142 const pawnShift
= color
== "w" ? -1 : 1;
144 // Do not cheat: the current enlightment is all we can see
145 const myLight
= JSON
.parse(JSON
.stringify(this.enlightened
[color
]));
147 // Can a slider on (i,j) apparently take my king?
148 // NOTE: inaccurate because assume yes if some squares are shadowed
149 const sliderTake
= ([i
, j
], piece
) => {
150 const kp
= this.kingPos
[color
];
151 let step
= undefined;
152 if (piece
== V
.BISHOP
) {
153 if (Math
.abs(kp
[0] - i
) == Math
.abs(kp
[1] - j
)) {
155 (i
- kp
[0]) / Math
.abs(i
- kp
[0]),
156 (j
- kp
[1]) / Math
.abs(j
- kp
[1])
159 } else if (piece
== V
.ROOK
) {
160 if (kp
[0] == i
) step
= [0, (j
- kp
[1]) / Math
.abs(j
- kp
[1])];
161 else if (kp
[1] == j
) step
= [(i
- kp
[0]) / Math
.abs(i
- kp
[0]), 0];
163 if (!step
) return false;
164 // Check for obstacles
165 let obstacle
= false;
167 let x
= kp
[0] + step
[0], y
= kp
[1] + step
[1];
169 x
+= step
[0], y
+= step
[1]
171 if (myLight
[x
][y
] && this.board
[x
][y
] != V
.EMPTY
) {
176 if (!obstacle
) return true;
180 // Do I see something which can take my king ?
181 const kingThreats
= () => {
182 const kp
= this.kingPos
[color
];
183 for (let i
= 0; i
< V
.size
.x
; i
++) {
184 for (let j
= 0; j
< V
.size
.y
; j
++) {
187 this.board
[i
][j
] != V
.EMPTY
&&
188 this.getColor(i
, j
) != color
190 switch (this.getPiece(i
, j
)) {
192 if (kp
[0] + pawnShift
== i
&& Math
.abs(kp
[1] - j
) == 1)
197 (Math
.abs(kp
[0] - i
) == 2 && Math
.abs(kp
[1] - j
) == 1) ||
198 (Math
.abs(kp
[0] - i
) == 1 && Math
.abs(kp
[1] - j
) == 2)
204 if (Math
.abs(kp
[0] - i
) == 1 && Math
.abs(kp
[1] - j
) == 1)
208 if (sliderTake([i
, j
], V
.BISHOP
)) return true;
211 if (sliderTake([i
, j
], V
.ROOK
)) return true;
214 if (sliderTake([i
, j
], V
.BISHOP
) || sliderTake([i
, j
], V
.ROOK
))
224 let moves
= this.getAllValidMoves();
225 for (let move of moves
) {
227 if (this.kingPos
[oppCol
][0] >= 0 && kingThreats()) {
228 // We didn't take opponent king, and our king will be captured: bad
229 move.eval
= -maxeval
;
233 if (move.eval
) continue;
235 move.eval
= 0; //a priori...
237 // Can I take something ? If yes, do it if it seems good...
238 if (move.vanish
.length
== 2 && move.vanish
[1].c
!= color
) {
239 // OK this isn't a castling move
240 const myPieceVal
= V
.VALUES
[move.appear
[0].p
];
241 const hisPieceVal
= V
.VALUES
[move.vanish
[1].p
];
243 if (myPieceVal
<= hisPieceVal
) move.eval
= hisPieceVal
- myPieceVal
+ 1;
245 // Taking a pawn with minor piece,
246 // or minor piece or pawn with a rook,
247 // or anything but a queen with a queen,
248 // or anything with a king.
249 move.eval
= hisPieceVal
- myPieceVal
;
250 //Math.random() < 0.5 ? 1 : -1;
255 // TODO: also need to implement the case when an opponent piece (in light)
256 // is threatening something - maybe not the king, but e.g. pawn takes rook.
258 moves
.sort((a
, b
) => b
.eval
- a
.eval
);
259 let candidates
= [0];
260 for (let j
= 1; j
< moves
.length
&& moves
[j
].eval
== moves
[0].eval
; j
++)
262 return moves
[candidates
[randInt(candidates
.length
)]];