Attempt to clarify installation instructions a little
[vchess.git] / client / src / variants / Atarigo.js
1 import { ChessRules, Move, PiPo } from "@/base_rules";
2 import { randInt } from "@/utils/alea";
3 import { ArrayFun } from "@/utils/array";
4
5 export class AtarigoRules extends ChessRules {
6
7 static get Options() {
8 return null;
9 }
10
11 static get Monochrome() {
12 return true;
13 }
14
15 static get Notoodark() {
16 return true;
17 }
18
19 static get Lines() {
20 let lines = [];
21 // Draw all inter-squares lines, shifted:
22 for (let i = 0; i < V.size.x; i++)
23 lines.push([[i+0.5, 0.5], [i+0.5, V.size.y-0.5]]);
24 for (let j = 0; j < V.size.y; j++)
25 lines.push([[0.5, j+0.5], [V.size.x-0.5, j+0.5]]);
26 return lines;
27 }
28
29 static get HasFlags() {
30 return false;
31 }
32
33 static get HasEnpassant() {
34 return false;
35 }
36
37 static get ReverseColors() {
38 return true;
39 }
40
41 static IsGoodPosition(position) {
42 if (position.length == 0) return false;
43 const rows = position.split("/");
44 if (rows.length != V.size.x) return false;
45 for (let row of rows) {
46 let sumElts = 0;
47 for (let i = 0; i < row.length; i++) {
48 if (row[i].toLowerCase() == V.PAWN) sumElts++;
49 else {
50 const num = parseInt(row[i], 10);
51 if (isNaN(num) || num <= 0) return false;
52 sumElts += num;
53 }
54 }
55 if (sumElts != V.size.y) return false;
56 }
57 return true;
58 }
59
60 static IsGoodFen(fen) {
61 if (!ChessRules.IsGoodFen(fen)) return false;
62 const fenParsed = V.ParseFen(fen);
63 // 3) Check capture "flag"
64 if (!fenParsed.capture || !fenParsed.capture.match(/^[01]$/))
65 return false;
66 return true;
67 }
68
69 static ParseFen(fen) {
70 const fenParts = fen.split(" ");
71 return Object.assign(
72 ChessRules.ParseFen(fen),
73 // Capture field allows to compute the score cleanly.
74 { capture: fenParts[3] }
75 );
76 }
77
78 static get size() {
79 return { x: 12, y: 12 };
80 }
81
82 static GenRandInitFen() {
83 return "93/93/93/93/93/5Pp5/5pP5/93/93/93/93/93 w 0 0";
84 }
85
86 getFen() {
87 return super.getFen() + " " + (this.capture ? 1 : 0);
88 }
89
90 setOtherVariables(fen) {
91 this.capture = parseInt(V.ParseFen(fen).capture, 10);
92 }
93
94 getPiece() {
95 return V.PAWN;
96 }
97
98 getPpath(b) {
99 return "Gomoku/" + b;
100 }
101
102 onlyClick() {
103 return true;
104 }
105
106 canIplay(side, [x, y]) {
107 return (side == this.turn && this.board[x][y] == V.EMPTY);
108 }
109
110 hoverHighlight([x, y], side) {
111 if (!!side && side != this.turn) return false;
112 return (this.board[x][y] == V.EMPTY);
113 }
114
115 searchForEmptySpace([x, y], color, explored) {
116 if (explored[x][y]) return false; //didn't find empty space
117 explored[x][y] = true;
118 let res = false;
119 for (let s of V.steps[V.ROOK]) {
120 const [i, j] = [x + s[0], y + s[1]];
121 if (V.OnBoard(i, j)) {
122 if (this.board[i][j] == V.EMPTY) res = true;
123 else if (this.getColor(i, j) == color)
124 res = this.searchForEmptySpace([i, j], color, explored) || res;
125 }
126 }
127 return res;
128 }
129
130 doClick([x, y]) {
131 const color = this.turn;
132 const oppCol = V.GetOppCol(color);
133 let move = new Move({
134 appear: [
135 new PiPo({ x: x, y: y, c: color, p: V.PAWN })
136 ],
137 vanish: [],
138 start: { x: -1, y: -1 }
139 });
140 V.PlayOnBoard(this.board, move); //put the stone
141 let noSuicide = false;
142 let captures = [];
143 for (let s of V.steps[V.ROOK]) {
144 const [i, j] = [x + s[0], y + s[1]];
145 if (V.OnBoard(i, j)) {
146 if (this.board[i][j] == V.EMPTY) noSuicide = true; //clearly
147 else if (this.getColor(i, j) == color) {
148 // Free space for us = not a suicide
149 if (!noSuicide) {
150 let explored = ArrayFun.init(V.size.x, V.size.y, false);
151 noSuicide = this.searchForEmptySpace([i, j], color, explored);
152 }
153 }
154 else {
155 // Free space for opponent = not a capture
156 let explored = ArrayFun.init(V.size.x, V.size.y, false);
157 const captureSomething =
158 !this.searchForEmptySpace([i, j], oppCol, explored);
159 if (captureSomething) {
160 for (let ii = 0; ii < V.size.x; ii++) {
161 for (let jj = 0; jj < V.size.y; jj++) {
162 if (explored[ii][jj]) {
163 captures.push(
164 new PiPo({ x: ii, y: jj, c: oppCol, p: V.PAWN })
165 );
166 }
167 }
168 }
169 }
170 }
171 }
172 }
173 V.UndoOnBoard(this.board, move); //remove the stone
174 if (!noSuicide && captures.length == 0) return null;
175 Array.prototype.push.apply(move.vanish, captures);
176 return move;
177 }
178
179 getPotentialMovesFrom([x, y]) {
180 const move = this.doClick([x, y]);
181 return (!move ? [] : [move]);
182 }
183
184 getAllPotentialMoves() {
185 let moves = [];
186 for (let i = 0; i < V.size.x; i++) {
187 for (let j=0; j < V.size.y; j++) {
188 if (this.board[i][j] == V.EMPTY) {
189 const mv = this.doClick([i, j]);
190 if (!!mv) moves.push(mv);
191 }
192 }
193 }
194 return moves;
195 }
196
197 filterValid(moves) {
198 return moves;
199 }
200
201 getCheckSquares() {
202 return [];
203 }
204
205 postPlay(move) {
206 if (move.vanish.length >= 1) this.capture = true;
207 }
208
209 postUndo() {
210 this.capture = false;
211 }
212
213 getCurrentScore() {
214 if (this.capture) return (this.turn == 'w' ? "0-1" : "1-0");
215 return "*";
216 }
217
218 // Modified version to count liberties + find locations
219 countEmptySpaces([x, y], color, explored) {
220 if (explored[x][y]) return [];
221 explored[x][y] = true;
222 let res = [];
223 for (let s of V.steps[V.ROOK]) {
224 const [i, j] = [x + s[0], y + s[1]];
225 if (V.OnBoard(i, j)) {
226 if (!explored[i][j] && this.board[i][j] == V.EMPTY) {
227 res.push([i, j]);
228 explored[i][j] = true; //not counting liberties twice!
229 }
230 else if (this.getColor(i, j) == color)
231 res = res.concat(this.countEmptySpaces([i, j], color, explored));
232 }
233 }
234 return res;
235 }
236
237 getComputerMove() {
238 const moves = super.getAllValidMoves();
239 if (moves.length == 0) return null;
240 // Any capture?
241 const captures = moves.filter(m => m.vanish.length >= 1);
242 if (captures.length > 0) return captures[randInt(captures.length)];
243 // Any group in immediate danger?
244 const color = this.turn;
245 let explored = ArrayFun.init(V.size.x, V.size.y, false);
246 for (let i = 0; i < V.size.x; i++) {
247 for (let j = 0; j < V.size.y; j++) {
248 if (
249 this.board[i][j] != V.EMPTY &&
250 this.getColor(i, j) == color &&
251 !explored[i][j]
252 ) {
253 // Before this search, reset liberties,
254 // because two groups might share them.
255 for (let ii = 0; ii < V.size.x; ii++) {
256 for (let jj = 0; jj < V.size.y; jj++) {
257 if (explored[ii][jj] && this.board[ii][jj] == V.EMPTY)
258 explored[ii][jj] = false;
259 }
260 }
261 const liberties = this.countEmptySpaces([i, j], color, explored);
262 if (liberties.length == 1) {
263 const L = liberties[0];
264 const toPlay = moves.find(m => m.end.x == L[0] && m.end.y == L[1]);
265 if (!!toPlay) return toPlay;
266 }
267 }
268 }
269 }
270 // At this point, pick a random move not far from current stones (TODO)
271 const candidates = moves.filter(m => {
272 const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
273 return (
274 steps.some(s => {
275 const [i, j] = [m.end.x + s[0], m.end.y + s[1]];
276 return (
277 V.OnBoard(i, j) &&
278 this.board[i][j] != V.EMPTY &&
279 this.getColor(i, j) == color
280 );
281 })
282 );
283 });
284 if (candidates.length > 0) return candidates[randInt(candidates.length)];
285 return moves[randInt(moves.length)];
286 }
287
288 getNotation(move) {
289 return V.CoordsToSquare(move.end);
290 }
291
292 };