1a006e22553cebc67e8f948ef308789e58e0a7ea
[xogo.git] / variants / Convert / class.js
1 import ChessRules from "/base_rules.js";
2 import PiPo from "/utils/PiPo.js";
3 import Move from "/utils/Move.js";
4
5 export default class ConvertRules extends ChessRules {
6
7 // TODO
8 static get Options() {
9 return {
10 select: C.Options.select,
11 input: C.Options.input,
12 styles: [
13 "atomic", "cannibal", "capture", "cylinder",
14 "dark", "madrasi", "rifle", "teleport"
15 ]
16 };
17 }
18
19 get hasEnpassant() {
20 return false;
21 }
22
23 setOtherVariables(fenParsed, pieceArray) {
24 super.setOtherVariables(fenParsed, pieceArray);
25 // Stack of "last move" only for intermediate chaining
26 this.lastMoveEnd = [null];
27 }
28
29 genRandInitBaseFen() {
30 const baseFen = super.genRandInitBaseFen();
31 return {
32 fen: baseFen.fen.replace("pppppppp/8", "8/pppppppp")
33 .replace("8/PPPPPPPP", "PPPPPPPP/8"),
34 o: baseFen.o
35 };
36 }
37
38 getBasicMove([sx, sy], [ex, ey], tr) {
39 const L = this.lastMoveEnd.length;
40 const lm = this.lastMoveEnd[L-1];
41 const piece = (!!lm ? lm.p : null);
42 const c = this.turn;
43 if (this.board[ex][ey] == "") {
44 if (piece && !tr)
45 tr = {c: c, p: piece};
46 let mv = super.getBasicMove([sx, sy], [ex, ey], tr);
47 if (piece)
48 mv.vanish.pop();
49 return mv;
50 }
51 // Capture: initial, or inside a chain
52 const initPiece = (piece || this.getPiece(sx, sy));
53 const oppCol = C.GetOppTurn(c);
54 const oppPiece = this.getPiece(ex, ey);
55 let mv = new Move({
56 start: {x: sx, y: sy},
57 end: {x: ex, y: ey},
58 appear: [
59 new PiPo({
60 x: ex,
61 y: ey,
62 c: c,
63 p: (!!tr ? tr.p : initPiece)
64 })
65 ],
66 vanish: [
67 new PiPo({
68 x: ex,
69 y: ey,
70 c: oppCol,
71 p: oppPiece
72 })
73 ]
74 });
75 if (!piece) {
76 // Initial capture
77 mv.vanish.unshift(
78 new PiPo({
79 x: sx,
80 y: sy,
81 c: c,
82 p: initPiece
83 })
84 );
85 }
86 return mv;
87 }
88
89 // TODO from here
90
91 getPotentialMovesFrom([x, y], asA) {
92 const L = this.lastMoveEnd.length;
93 if (!!this.lastMoveEnd[L-1]) {
94 if (x != this.lastMoveEnd[L-1].x || y != this.lastMoveEnd[L-1].y)
95 // A capture was played: wrong square
96 return [];
97 asA = this.lastMoveEnd[L-1].p;
98 }
99 switch (asA || this.getPiece(x, y)) {
100 case V.PAWN: return super.getPotentialPawnMoves([x, y]);
101 case V.ROOK: return super.getPotentialRookMoves([x, y]);
102 case V.KNIGHT: return super.getPotentialKnightMoves([x, y]);
103 case V.BISHOP: return super.getPotentialBishopMoves([x, y]);
104 case V.QUEEN: return super.getPotentialQueenMoves([x, y]);
105 case V.KING: return super.getPotentialKingMoves([x, y]);
106 }
107 return [];
108 }
109
110 getPossibleMovesFrom(sq) {
111 const L = this.lastMoveEnd.length;
112 let asA = undefined;
113 if (!!this.lastMoveEnd[L-1]) {
114 if (
115 sq[0] != this.lastMoveEnd[L-1].x ||
116 sq[1] != this.lastMoveEnd[L-1].y
117 ) {
118 return [];
119 }
120 asA = this.lastMoveEnd[L-1].p;
121 }
122 return this.filterValid(this.getPotentialMovesFrom(sq, asA));
123 }
124
125 isAttacked_aux([x, y], color, explored) {
126 if (explored.some(sq => sq[0] == x && sq[1] == y))
127 // Start of an infinite loop: exit
128 return false;
129 explored.push([x, y]);
130 if (super.isAttacked([x, y], color)) return true;
131 // Maybe indirect "chaining" attack:
132 const myColor = this.turn
133 let res = false;
134 let toCheck = []; //check all but king (no need)
135 // Pawns:
136 const shiftToPawn = (myColor == 'w' ? -1 : 1);
137 for (let yShift of [-1, 1]) {
138 const [i, j] = [x + shiftToPawn, y + yShift];
139 if (
140 V.OnBoard(i, j) &&
141 this.board[i][j] != V.EMPTY &&
142 // NOTE: no need to check color (no enemy pawn can take directly)
143 this.getPiece(i, j) == V.PAWN
144 ) {
145 toCheck.push([i, j]);
146 }
147 }
148 // Knights:
149 V.steps[V.KNIGHT].forEach(s => {
150 const [i, j] = [x + s[0], y + s[1]];
151 if (
152 V.OnBoard(i, j) &&
153 this.board[i][j] != V.EMPTY &&
154 this.getPiece(i, j) == V.KNIGHT
155 ) {
156 toCheck.push([i, j]);
157 }
158 });
159 // Sliders:
160 V.steps[V.ROOK].concat(V.steps[V.BISHOP]).forEach(s => {
161 let [i, j] = [x + s[0], y + s[1]];
162 while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
163 i += s[0];
164 j += s[1];
165 }
166 if (!V.OnBoard(i, j)) return;
167 const piece = this.getPiece(i, j);
168 if (
169 piece == V.QUEEN ||
170 (piece == V.ROOK && (s[0] == 0 || s[1] == 0)) ||
171 (piece == V.BISHOP && (s[0] != 0 && s[1] != 0))
172 ) {
173 toCheck.push([i, j]);
174 }
175 });
176 for (let ij of toCheck) {
177 if (this.isAttacked_aux(ij, color, explored)) return true;
178 }
179 return false;
180 }
181
182 isAttacked([x, y], color) {
183 let explored = [];
184 return this.isAttacked_aux([x, y], color, explored);
185 }
186
187 filterValid(moves) {
188 // No "checks" (except to forbid castle)
189 return moves;
190 }
191
192 prePlay(move) {
193 const c = this.turn;
194 // Extra conditions to avoid tracking converted kings:
195 if (
196 move.appear[0].p == V.KING &&
197 move.vanish.length >= 1 &&
198 move.vanish[0].p == V.KING
199 ) {
200 this.kingPos[c][0] = move.appear[0].x;
201 this.kingPos[c][1] = move.appear[0].y;
202 }
203 }
204
205 play(move) {
206 this.prePlay(move);
207 const c = this.turn;
208 move.flags = JSON.stringify(this.aggregateFlags());
209 V.PlayOnBoard(this.board, move);
210 if (!move.end.converted) {
211 // Not a capture: change turn
212 this.turn = V.GetOppCol(this.turn);
213 this.movesCount++;
214 this.lastMoveEnd.push(null);
215 }
216 else {
217 this.lastMoveEnd.push(
218 Object.assign({}, move.end, { p: move.end.converted })
219 );
220 }
221 super.updateCastleFlags(move, move.appear[0].p, c);
222 }
223
224 };