6a83374388749412854d0205a99696d09b9a6164
[xogo.git] / variants / Ambiguous / class.js
1 import ChessRules from "/base_rules.js";
2 import {FenUtil} from "/utils/setupPieces.js";
3
4 export default class AmbiguousRules extends ChessRules {
5
6 static get Options() {
7 return {
8 select: C.Options.select,
9 styles: ["cylinder"]
10 };
11 }
12
13 get hasFlags() {
14 return false;
15 }
16
17 setOtherVariables(fenParsed) {
18 super.setOtherVariables(fenParsed);
19 if (this.movesCount == 0)
20 this.subTurn = 2;
21 else
22 this.subTurn = 1;
23 }
24
25 genRandInitBaseFen() {
26 const s = FenUtil.setupPieces(
27 ['r', 'n', 'b', 'q', 'k', 'b', 'n', 'r'],
28 {
29 randomness: this.options["randomness"],
30 diffCol: ['b']
31 }
32 );
33 return {
34 fen: s.b.join("") + "/pppppppp/8/8/8/8/PPPPPPPP/" +
35 s.w.join("").toUpperCase(),
36 o: {}
37 };
38 }
39
40 canStepOver(x, y) {
41 return this.board[x][y] == "" || this.getPiece(x, y) == V.GOAL;
42 }
43
44 // Subturn 1: play a move for the opponent on the designated square.
45 // Subturn 2: play a move for me (which just indicate a square).
46 getPotentialMovesFrom([x, y]) {
47 const color = this.turn;
48 const oppCol = C.GetOppCol(color);
49 if (this.subTurn == 2) {
50 // Just play a normal move (which in fact only indicate a square)
51 let movesHash = {};
52 return (
53 super.getPotentialMovesFrom([x, y])
54 .filter(m => {
55 // Filter promotions: keep only one, since no choice for now.
56 if (m.appear[0].p != m.vanish[0].p) {
57 const hash = C.CoordsToSquare(m.start) + C.CoordsToSquare(m.end);
58 if (!movesHash[hash]) {
59 movesHash[hash] = true;
60 return true;
61 }
62 return false;
63 }
64 return true;
65 })
66 .map(m => {
67 if (m.vanish.length == 1)
68 m.appear[0].p = V.GOAL;
69 else {
70 m.appear[0].p = V.TARGET_CODE[m.vanish[1].p];
71 m.appear[0].c = m.vanish[1].c;
72 }
73 m.vanish.shift();
74 return m;
75 })
76 );
77 }
78 // At subTurn == 1, play a targeted move for the opponent.
79 // Search for target:
80 let target = {x: -1, y: -1};
81 outerLoop: for (let i = 0; i < this.size.x; i++) {
82 for (let j = 0; j < this.size.y; j++) {
83 if (this.board[i][j] != "") {
84 const piece = this.getPiece(i, j);
85 if (
86 piece == V.GOAL ||
87 Object.keys(V.TARGET_DECODE).includes(piece)
88 ) {
89 target = {x: i, y:j};
90 break outerLoop;
91 }
92 }
93 }
94 }
95 const moves = super.getPotentialMovesFrom([x, y], oppCol);
96 return moves.filter(m => m.end.x == target.x && m.end.y == target.y);
97 }
98
99 canIplay(x, y) {
100 const color = this.getColor(x, y);
101 return (
102 (this.subTurn == 1 && ![this.turn, this.playerColor].includes(color)) ||
103 (this.subTurn == 2 && super.canIplay(x, y))
104 );
105 }
106
107 // Code for empty square target
108 static get GOAL() {
109 return 'g';
110 }
111
112 static get TARGET_DECODE() {
113 return {
114 's': 'p',
115 't': 'q',
116 'u': 'r',
117 'o': 'n',
118 'c': 'b',
119 'l': 'k'
120 };
121 }
122
123 static get TARGET_CODE() {
124 return {
125 'p': 's',
126 'q': 't',
127 'r': 'u',
128 'n': 'o',
129 'b': 'c',
130 'k': 'l'
131 };
132 }
133
134 pieces(color, x, y) {
135 const targets = {
136 's': {"class": "target-pawn"},
137 'u': {"class": "target-rook"},
138 'o': {"class": "target-knight"},
139 'c': {"class": "target-bishop"},
140 't': {"class": "target-queen"},
141 'l': {"class": "target-king"}
142 };
143 return Object.assign({ 'g': {"class": "target"} },
144 targets, super.pieces(color, x, y));
145 }
146
147 atLeastOneMove() {
148 // Since there are no checks this seems true (same as for Magnetic...)
149 return true;
150 }
151
152 filterValid(moves) {
153 return moves;
154 }
155
156 isKing(x, y, p) {
157 if (!p)
158 p = this.getPiece(x, y);
159 return ['k', 'l'].includes(p);
160 }
161
162 getCurrentScore() {
163 // This function is only called at subTurn 1
164 const color = C.GetOppCol(this.turn);
165 if (this.searchKingPos(color).length == 0)
166 return (color == 'w' ? "0-1" : "1-0");
167 return "*";
168 }
169
170 postPlay(move) {
171 const color = this.turn;
172 if (this.subTurn == 2 || this.searchKingPos(color).length == 0) {
173 this.turn = C.GetOppCol(color);
174 this.movesCount++;
175 }
176 this.subTurn = 3 - this.subTurn;
177 }
178
179 };