Fix Weiqi
[xogo.git] / variants / Bario / class.js
CommitLineData
dc10e429
BA
1import ChessRules from "/base_rules.js";
2import PiPo from "/utils/PiPo.js";
3import Move from "/utils/Move.js";
4
5export default class BarioRules extends ChessRules {
6
7 static get Options() {
8 return {
0e466aac
BA
9 select: C.Options.select,
10 input: C.Options.input,
dc10e429
BA
11 styles: [
12 "atomic", "cannibal", "capture", "cylinder",
13 "dark", "madrasi", "rifle", "teleport"
14 ]
15 };
16 }
17
18 // Does not really seem necessary (although the author mention it)
19 // Instead, first move = pick a square for the king.
20 get hasFlags() {
21 return false;
22 }
23 get hasReserve() {
24 return true;
25 }
26
27 pieces(color, x, y) {
28 return Object.assign(
29 {
30 'u': {
31 "class": "undefined",
32 moves: []
33 }
34 },
35 super.pieces(color, x, y)
36 );
37 }
38
39 get onlyClick() {
40 return this.movesCount <= 1;
41 }
42
43 // Initiate the game by choosing a square for the king:
44 doClick(coords) {
45 const color = this.turn;
46 if (
47 this.movesCount <= 1 &&
48 (
49 (color == 'w' && coords.x == this.size.x - 1) ||
50 (color == 'b' && coords.x == 0)
51 )
52 ) {
53 return new Move({
54 appear: [ new PiPo({x: coords.x, y: coords.y, c: color, p: 'k' }) ],
55 vanish: [ new PiPo({x: coords.x, y: coords.y, c: color, p: 'u' }) ]
56 });
57 }
58 return null;
59 }
60
61 genRandInitBaseFen() {
62 return {
63 fen: "uuuuuuuu/pppppppp/8/8/8/8/PPPPPPPP/UUUUUUUU",
64 o: {}
65 }
66 }
67
68 getPartFen(o) {
69 return Object.assign(
70 {
71 captureUndef: (o.init || !this.captureUndef)
72 ? "-"
73 : C.CoordsToSquare(this.captureUndef)
74 },
75 super.getPartFen(o)
76 );
77 }
78
79 getReserveFen(o) {
80 if (o.init)
81 return "22212221";
82 return (
83 ["w","b"].map(c => Object.values(this.reserve[c]).join("")).join("")
84 );
85 }
86
87 initReserves(reserveStr) {
88 super.initReserves(reserveStr, ['r', 'n', 'b', 'q']);
89 }
90
91 setOtherVariables(fenParsed) {
92 super.setOtherVariables(fenParsed);
93 this.captureUndef = fenParsed.captureUndef == '-'
94 ? null :
95 C.SquareToCoords(fenParsed.captureUndef);
96 this.definition = null;
97 }
98
99 canDrop([c, p], [i, j]) {
100 switch (this.subTurn) {
101 case 0:
102 return i == this.captureUndef.x && j == this.captureUndef.y;
103 case 1:
104 return this.getPiece(i, j) == 'u' && c == this.getColor(i, j);
105 }
106 return false; //never reached
107 }
108
109 getPotentialMovesFrom([x, y]) {
110 if (this.movesCount <= 1)
111 return [];
112 let moves = [];
113 switch (this.subTurn) {
114 case 0:
115 if (typeof x == "string")
116 moves = this.getDropMovesFrom([x, y]);
2fdfb05d
BA
117 // Empty move: just start + end
118 moves.forEach(m => {m.vanish.pop(); m.appear.pop();});
dc10e429
BA
119 break;
120 case 1:
121 // Both normal move (from defined piece) and definition allowed
122 if (typeof x == "string")
123 moves = this.getDropMovesFrom([x, y]);
124 else if (this.getPiece(x, y) != 'u')
125 moves = super.getPotentialMovesFrom([x, y]);
126 break;
127 case 2:
128 // We can only move the just-defined piece
129 if (x == this.definition.x && y == this.definition.y)
130 moves = super.getPotentialMovesFrom([x, y]);
131 break;
132 }
133 return moves;
134 }
135
136 filterValid(moves) {
137 if (this.movesCount <= 1 || this.subTurn == 0)
138 return moves;
182ba661 139 let filterLater = [];
dc10e429 140 if (this.subTurn == 1) {
182ba661
BA
141 // Remove defining moves with un-movable def piece,
142 // and separate compatible definitions.
dc10e429
BA
143 moves = moves.filter(m => {
144 if (m.vanish.length >= 2 || m.vanish[0].p != 'u')
145 return true;
146 this.playOnBoard(m);
147 const canMove = super.filterValid(
148 super.getPotentialMovesFrom([m.end.x, m.end.y])).length >= 1;
149 this.undoOnBoard(m);
182ba661
BA
150 if (canMove)
151 filterLater.push(m);
152 return false;
dc10e429
BA
153 });
154 }
182ba661 155 return super.filterValid(moves).concat(filterLater);
dc10e429
BA
156 }
157
158 atLeastOneMove(color) {
159 if (this.subTurn != 1)
160 return true;
161 return super.atLeastOneMove(color);
162 }
163
dc10e429
BA
164 underCheck(square_s, oppCol) {
165 if (super.underCheck(square_s, oppCol))
166 return true;
167 // Check potential specializations of undefined using reserve:
168 const allAttacks = Array.prototype.concat.apply(
169 ['r', 'n', 'b', 'q'].map(p => this.pieces()[p].moves[0]));
182ba661 170 const [x, y] = square_s[0];
dc10e429
BA
171 for (let i=0; i<this.size.x; i++) {
172 for (let j=0; j<this.size.y; j++) {
173 if (
174 this.board[i][j] != "" &&
175 this.getColor(i, j) == oppCol &&
176 this.getPiece(i, j) == 'u'
177 ) {
178 for (let stepDef of allAttacks) {
179 for (let s of stepDef.steps) {
180 if (!super.compatibleStep([i, j], [x, y], s, stepDef.range))
181 continue;
182 if (
183 super.findDestSquares(
184 [i, j],
185 {
186 captureTarget: [x, y],
187 captureSteps: [{steps: [s], range: stepDef.range}],
188 segments: false,
189 attackOnly: true,
190 one: false
191 }
192 )
193 ) {
194 return true;
195 }
196 }
197 }
198 }
199 }
200 }
201 return false;
202 }
203
dc10e429
BA
204 postPlay(move) {
205 const color = this.turn;
74d30010 206 if (this.movesCount <= 1 || move.reset || move.next) {
2fdfb05d
BA
207 if (!move.next)
208 this.tryChangeTurn();
dc10e429
BA
209 return;
210 }
182ba661
BA
211 if (this.subTurn == 0)
212 this.captureUndef = null; //already used
dc10e429 213 const captureUndef = (
182ba661 214 move.vanish.length == 2 && //exclude subTurn == 0
dc10e429
BA
215 move.vanish[1].c != color &&
216 move.vanish[1].p == 'u'
217 );
218 if (typeof move.start.x == "number" && !captureUndef)
219 // Normal move (including Teleport)
220 super.postPlay(move);
221 else if (typeof move.start.x == "string") {
182ba661 222 super.updateReserve(
2fdfb05d 223 color, move.start.y, this.reserve[color][move.start.y] - 1);
dc10e429
BA
224 if (move.vanish.length == 1 && move.vanish[0].p == 'u')
225 this.definition = move.end;
226 this.subTurn++;
227 }
228 else {
229 this.subTurn = 0;
230 this.captureUndef = move.end;
2fdfb05d 231 this.tryChangeTurn(null, captureUndef);
182ba661
BA
232 }
233 }
234
2fdfb05d 235 // NOTE: not "trying", the turn always change here (TODO?)
182ba661 236 tryChangeTurn(move, captureUndef) {
2fdfb05d
BA
237 this.definition = null;
238 this.subTurn = captureUndef ? 0 : 1;
239 this.turn = C.GetOppCol(this.turn);
240 this.movesCount++;
182ba661
BA
241 }
242
243 computeNextMove(move) {
244 if (
245 !this.definition || this.playerColor != this.turn ||
246 this.board.some(row => row.some(cell =>
247 cell.charAt(0) == this.turn && cell.charAt(1) == 'u'))
248 ) {
74d30010 249 return;
182ba661
BA
250 }
251 const variety = (c) => {
252 return (
253 [...new Set(
254 Array.prototype.concat.apply([],
255 this.board.map(row =>
256 row.filter(cell =>
257 cell.charAt(0) == c && !['p', 'k'].includes(cell.charAt(1))
258 ).map(cell => cell.charAt(1))
259 )
260 )
261 )].length >= 2
262 );
263 };
182ba661 264 let next = {start: move.end, end: move.end, vanish: [], appear: []};
74d30010
BA
265 this.playOnBoard(move);
266 const twoOrMorePieces = {w: variety('w'), b: variety('b')};
267 const resetCols =
268 Object.keys(twoOrMorePieces).filter(k => twoOrMorePieces[k]);
269 if (resetCols.length >= 1) {
270 for (let i=0; i<this.size.x; i++) {
271 for (let j=0; j<this.size.y; j++) {
272 const colIJ = this.getColor(i, j);
273 const pieceIJ = this.getPiece(i, j);
274 if (
275 resetCols.includes(colIJ) &&
276 this.board[i][j] != "" &&
277 !['p', 'k', 'u'].includes(pieceIJ)
278 ) {
279 // NOTE: could also use a "flip" strategy similar to Benedict
280 next.vanish.push(new PiPo({c: colIJ, p: pieceIJ, x: i, y: j}));
281 next.appear.push(new PiPo({c: colIJ, p: 'u', x: i, y: j}));
282 this.reserve[colIJ][pieceIJ]++;
182ba661
BA
283 }
284 }
182ba661 285 }
74d30010 286 super.re_drawReserve(resetCols);
182ba661
BA
287 }
288 this.undoOnBoard(move);
289 if (next.vanish.length >= 1) {
290 next.reset = true;
291 move.next = next;
dc10e429
BA
292 }
293 }
294
295 isLastMove() {
296 return true; //called only on normal moves (not Teleport)
297 }
298
299 getCurrentScore(move_s) {
300 return (this.movesCount <= 2 ? "*" : super.getCurrentScore(move_s));
301 }
302
303};