Commit | Line | Data |
---|---|---|
9bd6786b BA |
1 | import { ChessRules, PiPo, Move } from "@/base_rules"; |
2 | ||
3 | export const VariantRules = class BenedictRules extends ChessRules { | |
4 | static get HasEnpassant() { | |
5 | return false; | |
6 | } | |
7 | ||
8 | // TODO(?): some duplicated code in 2 next functions | |
9 | getSlideNJumpMoves([x, y], steps, oneStep) { | |
10 | let moves = []; | |
11 | outerLoop: for (let loop = 0; loop < steps.length; loop++) { | |
12 | const step = steps[loop]; | |
13 | let i = x + step[0]; | |
14 | let j = y + step[1]; | |
15 | while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) { | |
16 | moves.push(this.getBasicMove([x, y], [i, j])); | |
17 | if (oneStep) continue outerLoop; | |
18 | i += step[0]; | |
19 | j += step[1]; | |
20 | } | |
21 | // No capture check: handled elsewhere (next method) | |
22 | } | |
23 | return moves; | |
24 | } | |
25 | ||
26 | // Find possible captures from a square | |
27 | // follow steps from x,y until something is met. | |
28 | findCaptures([x, y]) { | |
29 | const color = this.getColor(x, y); | |
30 | const piece = this.getPiece(x, y); | |
31 | let squares = []; | |
32 | const steps = | |
33 | piece != V.PAWN | |
34 | ? [V.QUEEN,V.KING].includes(piece) | |
35 | ? V.steps[V.ROOK].concat(V.steps[V.BISHOP]) | |
36 | : V.steps[piece] | |
37 | : color == "w" | |
38 | ? [ | |
39 | [-1, -1], | |
40 | [-1, 1] | |
41 | ] | |
42 | : [ | |
43 | [1, -1], | |
44 | [1, 1] | |
45 | ]; | |
46 | const oneStep = [V.KNIGHT,V.PAWN,V.KING].includes(piece); | |
47 | outerLoop: for (let loop = 0; loop < steps.length; loop++) { | |
48 | const step = steps[loop]; | |
49 | let i = x + step[0]; | |
50 | let j = y + step[1]; | |
51 | while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) { | |
52 | if (oneStep) continue outerLoop; | |
53 | i += step[0]; | |
54 | j += step[1]; | |
55 | } | |
56 | if ( | |
57 | V.OnBoard(i, j) && | |
58 | this.getColor(i, j) == V.GetOppCol(color) | |
59 | ) { | |
60 | // eat! | |
61 | squares.push([i, j]); | |
62 | } | |
63 | } | |
64 | return squares; | |
65 | } | |
66 | ||
67 | getPotentialPawnMoves([x, y]) { | |
68 | const color = this.getColor(x, y); | |
69 | let moves = []; | |
70 | const sizeY = V.size.y; | |
71 | const shift = color == "w" ? -1 : 1; | |
72 | const startRank = color == "w" ? sizeY - 2 : 1; | |
73 | const firstRank = color == "w" ? sizeY - 1 : 0; | |
74 | const lastRank = color == "w" ? 0 : sizeY - 1; | |
75 | ||
76 | if (x + shift != lastRank) { | |
77 | // Normal moves | |
78 | if (this.board[x + shift][y] == V.EMPTY) { | |
79 | moves.push(this.getBasicMove([x, y], [x + shift, y])); | |
80 | if ( | |
81 | [startRank, firstRank].includes(x) && | |
82 | this.board[x + 2 * shift][y] == V.EMPTY | |
83 | ) { | |
84 | // Two squares jump | |
85 | moves.push(this.getBasicMove([x, y], [x + 2 * shift, y])); | |
86 | } | |
87 | } | |
88 | } | |
89 | else { | |
90 | // Promotion | |
91 | let promotionPieces = [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]; | |
92 | promotionPieces.forEach(p => { | |
93 | // Normal move | |
94 | if (this.board[x + shift][y] == V.EMPTY) | |
95 | moves.push( | |
96 | this.getBasicMove([x, y], [x + shift, y], { c: color, p: p }) | |
97 | ); | |
98 | }); | |
99 | } | |
100 | ||
101 | // No en passant here | |
102 | ||
103 | return moves; | |
104 | } | |
105 | ||
106 | getPotentialRookMoves(sq) { | |
107 | return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]); | |
108 | } | |
109 | ||
110 | getPotentialKnightMoves(sq) { | |
111 | return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep"); | |
112 | } | |
113 | ||
114 | getPotentialBishopMoves(sq) { | |
115 | return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]); | |
116 | } | |
117 | ||
118 | getPotentialQueenMoves(sq) { | |
119 | return this.getSlideNJumpMoves( | |
120 | sq, | |
121 | V.steps[V.ROOK].concat(V.steps[V.BISHOP]) | |
122 | ); | |
123 | } | |
124 | ||
125 | getPotentialKingMoves(sq) { | |
126 | // Initialize with normal (non-capturing) moves | |
127 | let noCaptures = this.getSlideNJumpMoves( | |
128 | sq, | |
129 | V.steps[V.ROOK].concat(V.steps[V.BISHOP]), | |
130 | "oneStep" | |
131 | ); | |
132 | return noCaptures.concat(this.getCastleMoves(sq)); | |
133 | } | |
134 | ||
135 | // TODO: appear/vanish description of a move is too verbose for Benedict. | |
136 | // => Would need a new "flipped" array, to be passed in Game.vue... | |
137 | getPotentialMovesFrom([x, y]) { | |
138 | const color = this.turn; | |
139 | const oppCol = V.GetOppCol(color); | |
140 | // Get all moves from x,y without captures: | |
141 | let moves = super.getPotentialMovesFrom([x, y]); | |
142 | // Add flips: | |
1af00c56 BA |
143 | let newAppear = []; |
144 | let newVanish = []; | |
9bd6786b BA |
145 | moves.forEach(m => { |
146 | V.PlayOnBoard(this.board, m); | |
1af00c56 BA |
147 | // If castling, m.appear has 2 elements: |
148 | m.appear.forEach(a => { | |
149 | const flipped = this.findCaptures([a.x, a.y]); | |
150 | flipped.forEach(sq => { | |
151 | const piece = this.getPiece(sq[0],sq[1]); | |
152 | const pipoA = new PiPo({ | |
153 | x:sq[0], | |
154 | y:sq[1], | |
155 | c:color, | |
156 | p:piece | |
157 | }); | |
158 | const pipoV = new PiPo({ | |
159 | x:sq[0], | |
160 | y:sq[1], | |
161 | c:oppCol, | |
162 | p:piece | |
163 | }); | |
164 | newAppear.push(pipoA); | |
165 | newVanish.push(pipoV); | |
9bd6786b | 166 | }); |
1af00c56 BA |
167 | Array.prototype.push.apply(m.appear, newAppear); |
168 | Array.prototype.push.apply(m.vanish, newVanish); | |
9bd6786b | 169 | }); |
1af00c56 | 170 | V.UndoOnBoard(this.board, m); |
9bd6786b BA |
171 | }); |
172 | return moves; | |
173 | } | |
174 | ||
175 | // Moves cannot flip our king's color, so all are valid | |
176 | filterValid(moves) { | |
177 | return moves; | |
178 | } | |
179 | ||
180 | // No notion of check here: | |
181 | getCheckSquares() { | |
182 | return []; | |
183 | } | |
184 | ||
1af00c56 BA |
185 | // Stop at the first move found |
186 | atLeastOneMove() { | |
187 | const color = this.turn; | |
188 | const oppCol = V.GetOppCol(color); | |
189 | for (let i = 0; i < V.size.x; i++) { | |
190 | for (let j = 0; j < V.size.y; j++) { | |
191 | if (this.board[i][j] != V.EMPTY && this.getColor(i, j) != oppCol) { | |
192 | const moves = this.getPotentialMovesFrom([i, j]); | |
193 | if (moves.length > 0) | |
194 | return true; | |
195 | } | |
196 | } | |
197 | } | |
198 | return false; | |
199 | } | |
200 | ||
9bd6786b BA |
201 | getCurrentScore() { |
202 | const color = this.turn; | |
203 | // Did a king change color? | |
204 | const kp = this.kingPos[color]; | |
205 | if (this.getColor(kp[0], kp[1]) != color) | |
206 | return color == "w" ? "0-1" : "1-0"; | |
1af00c56 BA |
207 | if (this.atLeastOneMove()) |
208 | return "*"; | |
209 | // Stalemate: | |
210 | return "1/2"; | |
9bd6786b BA |
211 | } |
212 | }; |