X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FMarseille.js;h=90084dc28f271daa86d64f15e76c47a8444c1180;hb=d1a0cce3c1e05352c6017a77186b5e31a523490f;hp=19d35a63a730c522dc030e699217786d125d2041;hpb=6808d7a16ec1e761c6a2dffec2281c96953e4d89;p=vchess.git diff --git a/client/src/variants/Marseille.js b/client/src/variants/Marseille.js index 19d35a63..90084dc2 100644 --- a/client/src/variants/Marseille.js +++ b/client/src/variants/Marseille.js @@ -1,12 +1,12 @@ import { ChessRules } from "@/base_rules"; import { randInt } from "@/utils/alea"; -export const VariantRules = class MarseilleRules extends ChessRules { +export class MarseilleRules extends ChessRules { static IsGoodEnpassant(enpassant) { - if (enpassant != "-") { - const squares = enpassant.split(","); - if (squares.length > 2) return false; - for (let sq of squares) { + const squares = enpassant.split(","); + if (squares.length > 2) return false; + for (let sq of squares) { + if (sq != "-") { const ep = V.SquareToCoords(sq); if (isNaN(ep.x) || !V.OnBoard(ep)) return false; } @@ -14,85 +14,31 @@ export const VariantRules = class MarseilleRules extends ChessRules { return true; } - getTurnFen() { - return this.turn + this.subTurn; - } - // There may be 2 enPassant squares (if 2 pawns jump 2 squares in same turn) getEnpassantFen() { - const L = this.epSquares.length; - if (this.epSquares[L - 1].every(epsq => epsq === undefined)) return "-"; //no en-passant - let res = ""; - this.epSquares[L - 1].forEach(epsq => { - if (epsq) res += V.CoordsToSquare(epsq) + ","; - }); - return res.slice(0, -1); //remove last comma + return this.epSquares[this.epSquares.length - 1].map( + epsq => epsq === undefined + ? "-" //no en-passant + : V.CoordsToSquare(epsq) + ).join(","); } setOtherVariables(fen) { const parsedFen = V.ParseFen(fen); this.setFlags(parsedFen.flags); - if (parsedFen.enpassant == "-") this.epSquares = [[undefined]]; - else { - let res = []; - const squares = parsedFen.enpassant.split(","); - for (let sq of squares) res.push(V.SquareToCoords(sq)); - this.epSquares = [res]; - } - this.scanKingsRooks(fen); + this.epSquares = [parsedFen.enpassant.split(",").map(sq => { + if (sq != "-") return V.SquareToCoords(sq); + return undefined; + })]; + this.scanKings(fen); // Extract subTurn from turn indicator: "w" (first move), or // "w1" or "w2" white subturn 1 or 2, and same for black - const fullTurn = V.ParseFen(fen).turn; - this.turn = fullTurn[0]; - this.subTurn = fullTurn[1] || 0; //"w0" = special code for first move in game + this.turn = parsedFen.turn; + this.subTurn = 1; } - getPotentialPawnMoves([x, y]) { - const color = this.turn; + getEnpassantCaptures([x, y], shiftX) { let moves = []; - const [sizeX, sizeY] = [V.size.x, V.size.y]; - const shiftX = color == "w" ? -1 : 1; - const firstRank = color == "w" ? sizeX - 1 : 0; - const startRank = color == "w" ? sizeX - 2 : 1; - const lastRank = color == "w" ? 0 : sizeX - 1; - const finalPieces = - x + shiftX == lastRank ? [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN] : [V.PAWN]; - - // One square forward - if (this.board[x + shiftX][y] == V.EMPTY) { - for (let piece of finalPieces) { - moves.push( - this.getBasicMove([x, y], [x + shiftX, y], { c: color, p: piece }) - ); - } - // Next condition because pawns on 1st rank can generally jump - if ( - [startRank, firstRank].includes(x) && - this.board[x + 2 * shiftX][y] == V.EMPTY - ) { - // Two squares jump - moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y])); - } - } - // Captures - for (let shiftY of [-1, 1]) { - if ( - y + shiftY >= 0 && - y + shiftY < sizeY && - this.board[x + shiftX][y + shiftY] != V.EMPTY && - this.canTake([x, y], [x + shiftX, y + shiftY]) - ) { - for (let piece of finalPieces) { - moves.push( - this.getBasicMove([x, y], [x + shiftX, y + shiftY], { - c: color, - p: piece - }) - ); - } - } - } - // En passant: always OK if subturn 1, // OK on subturn 2 only if enPassant was played at subturn 1 // (and if there are two e.p. squares available). @@ -103,7 +49,7 @@ export const VariantRules = class MarseilleRules extends ChessRules { if (sq) epSqs.push(sq); }); if (epSqs.length == 0) return moves; - const oppCol = V.GetOppCol(color); + const oppCol = V.GetOppCol(this.getColor(x, y)); for (let sq of epSqs) { if ( this.subTurn == 1 || @@ -130,7 +76,6 @@ export const VariantRules = class MarseilleRules extends ChessRules { } } } - return moves; } @@ -139,41 +84,76 @@ export const VariantRules = class MarseilleRules extends ChessRules { move.turn = this.turn + this.subTurn; V.PlayOnBoard(this.board, move); const epSq = this.getEpSquare(move); - if (this.subTurn == 0) { - //first move in game + if (this.movesCount == 0) { + // First move in game this.turn = "b"; - this.subTurn = 1; this.epSquares.push([epSq]); + this.movesCount = 1; } // Does this move give check on subturn 1? If yes, skip subturn 2 else if (this.subTurn == 1 && this.underCheck(V.GetOppCol(this.turn))) { this.turn = V.GetOppCol(this.turn); this.epSquares.push([epSq]); move.checkOnSubturn1 = true; + this.movesCount++; } else { if (this.subTurn == 2) { this.turn = V.GetOppCol(this.turn); let lastEpsq = this.epSquares[this.epSquares.length - 1]; lastEpsq.push(epSq); - } else this.epSquares.push([epSq]); + } else { + this.epSquares.push([epSq]); + this.movesCount++; + } this.subTurn = 3 - this.subTurn; } - this.updateVariables(move); + this.postPlay(move); + } + + postPlay(move) { + const c = move.turn.charAt(0); + const piece = move.vanish[0].p; + const firstRank = c == "w" ? V.size.x - 1 : 0; + + if (piece == V.KING && move.appear.length > 0) { + this.kingPos[c][0] = move.appear[0].x; + this.kingPos[c][1] = move.appear[0].y; + this.castleFlags[c] = [V.size.y, V.size.y]; + return; + } + const oppCol = V.GetOppCol(c); + const oppFirstRank = V.size.x - 1 - firstRank; + if ( + move.start.x == firstRank && //our rook moves? + this.castleFlags[c].includes(move.start.y) + ) { + const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1); + this.castleFlags[c][flagIdx] = V.size.y; + } else if ( + move.end.x == oppFirstRank && //we took opponent rook? + this.castleFlags[oppCol].includes(move.end.y) + ) { + const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1); + this.castleFlags[oppCol][flagIdx] = V.size.y; + } } undo(move) { this.disaggregateFlags(JSON.parse(move.flags)); V.UndoOnBoard(this.board, move); - if (move.turn[1] == "0" || move.checkOnSubturn1 || this.subTurn == 2) + if (this.movesCount == 1 || !!move.checkOnSubturn1 || this.subTurn == 2) { + // The move may not be full, but is fully undone: this.epSquares.pop(); - //this.subTurn == 1 - else { + // Moves counter was just incremented: + this.movesCount--; + } else { + // Undo the second half of a move let lastEpsq = this.epSquares[this.epSquares.length - 1]; lastEpsq.pop(); } this.turn = move.turn[0]; this.subTurn = parseInt(move.turn[1]); - this.unupdateVariables(move); + super.postUndo(move); } // NOTE: GenRandInitFen() is OK, @@ -192,8 +172,6 @@ export const VariantRules = class MarseilleRules extends ChessRules { // No alpha-beta here, just adapted min-max at depth 2(+1) getComputerMove() { - if (this.subTurn == 2) return null; //TODO: imperfect interface setup - const maxeval = V.INFINITY; const color = this.turn; const oppCol = V.GetOppCol(this.turn);