X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=public%2Fjavascripts%2Fvariants%2FAlice.js;h=b7f5a3e1cd77ab191dea341bfe9d82d72fa9f7fb;hb=efb20746c30ac26f258f9c5de6dfb70b91980de4;hp=3d79580fd7977c92effb4046e39c9ddd1e531726;hpb=9de73b71a1db5464f89a202e6cdfdc7b6b6b0753;p=vchess.git diff --git a/public/javascripts/variants/Alice.js b/public/javascripts/variants/Alice.js index 3d79580f..b7f5a3e1 100644 --- a/public/javascripts/variants/Alice.js +++ b/public/javascripts/variants/Alice.js @@ -1,3 +1,4 @@ +// NOTE: alternative implementation, probably cleaner = use only 1 board class AliceRules extends ChessRules { static get ALICE_PIECES() @@ -60,11 +61,10 @@ class AliceRules extends ChessRules } } - getBoardOfPiece([x,y]) + // Build board of the given (mirror)side + getSideBoard(mirrorSide) { const V = VariantRules; - // Build board where the piece is - const mirrorSide = (Object.keys(V.ALICE_CODES).includes(this.getPiece(x,y)) ? 1 : 2); // Build corresponding board from complete board const [sizeX,sizeY] = V.size; let sideBoard = doubleArray(sizeX, sizeY, ""); @@ -82,22 +82,21 @@ class AliceRules extends ChessRules return sideBoard; } - // TODO: move board building one level up (findAllMoves()) to avoid re-building at every piece... // NOTE: castle & enPassant https://www.chessvariants.com/other.dir/alice.html - // --> Should be OK as is. - getPotentialMovesFrom([x,y]) + getPotentialMovesFrom([x,y], sideBoard) { - let sideBoard = this.getBoardOfPiece([x,y]); + const pieces = Object.keys(VariantRules.ALICE_CODES); + const codes = Object.keys(VariantRules.ALICE_PIECES); + const mirrorSide = (pieces.includes(this.getPiece(x,y)) ? 1 : 2); // Search valid moves on sideBoard let saveBoard = this.board; - this.board = sideBoard; + this.board = sideBoard || this.getSideBoard(mirrorSide); let moves = super.getPotentialMovesFrom([x,y]); this.board = saveBoard; // Finally filter impossible moves - const mirrorSide = (Object.keys(VariantRules.ALICE_CODES).includes(this.getPiece(x,y)) ? 1 : 2); - return moves.filter(m => { + let res = moves.filter(m => { if (m.appear.length == 2) //castle { // If appear[i] not in vanish array, then must be empty square on other board @@ -113,8 +112,8 @@ class AliceRules extends ChessRules { // Attempt to capture const piece = this.getPiece(m.end.x,m.end.y); - if ((mirrorSide==1 && Object.keys(VariantRules.ALICE_PIECES).includes(piece)) - || (mirrorSide==2 && Object.keys(VariantRules.ALICE_CODES).includes(piece))) + if ((mirrorSide==1 && codes.includes(piece)) + || (mirrorSide==2 && pieces.includes(piece))) { return false; } @@ -133,22 +132,100 @@ class AliceRules extends ChessRules }); } // Fix en-passant captures - if (m.vanish.length == 2 && this.board[m.end.x][m.end.y] == VariantRules.EMPTY) + if (m.vanish[0].p == VariantRules.PAWN + && m.vanish.length == 2 && this.board[m.end.x][m.end.y] == VariantRules.EMPTY) + { m.vanish[1].c = this.getOppCol(this.getColor(x,y)); + // In the special case of en-passant, if + // - board1 takes board2 : vanish[1] --> Alice + // - board2 takes board1 : vanish[1] --> normal + let van = m.vanish[1]; + if (mirrorSide==1 && codes.includes(this.getPiece(van.x,van.y))) + van.p = VariantRules.ALICE_CODES[van.p]; + else if (mirrorSide==2 && pieces.includes(this.getPiece(van.x,van.y))) + van.p = VariantRules.ALICE_PIECES[van.p]; + } return true; }); + return res; + } + + filterValid(moves) + { + if (moves.length == 0) + return []; + let sideBoard = [this.getSideBoard(1), this.getSideBoard(2)]; + return moves.filter(m => { return !this.underCheck(m, sideBoard); }); } - underCheck(move) + getAllValidMoves() { const color = this.turn; - this.play(move); - let sideBoard = this.getBoardOfPiece(this.kingPos[color]); + const oppCol = this.getOppCol(color); + var potentialMoves = []; + let [sizeX,sizeY] = VariantRules.size; + let sideBoard = [this.getSideBoard(1), this.getSideBoard(2)]; + for (var i=0; i { + const mirrorSide = (pieces.includes(psq.p) ? 1 : 2); + sideBoard[mirrorSide-1][psq.x][psq.y] = VariantRules.EMPTY; + }); + move.appear.forEach(psq => { + const mirrorSide = (pieces.includes(psq.p) ? 1 : 2); + const piece = (mirrorSide == 1 ? psq.p : VariantRules.ALICE_PIECES[psq.p]); + sideBoard[mirrorSide-1][psq.x][psq.y] = psq.c + piece; + if (piece == VariantRules.KING) + this.kingPos[psq.c] = [psq.x,psq.y]; + }); + } + + // Undo on sideboards + undoSide(move, sideBoard) + { + const pieces = Object.keys(VariantRules.ALICE_CODES); + move.appear.forEach(psq => { + const mirrorSide = (pieces.includes(psq.p) ? 1 : 2); + sideBoard[mirrorSide-1][psq.x][psq.y] = VariantRules.EMPTY; + }); + move.vanish.forEach(psq => { + const mirrorSide = (pieces.includes(psq.p) ? 1 : 2); + const piece = (mirrorSide == 1 ? psq.p : VariantRules.ALICE_PIECES[psq.p]); + sideBoard[mirrorSide-1][psq.x][psq.y] = psq.c + piece; + if (piece == VariantRules.KING) + this.kingPos[psq.c] = [psq.x,psq.y]; + }); + } + + underCheck(move, sideBoard) //sideBoard arg always provided + { + const color = this.turn; + this.playSide(move, sideBoard); //no need to track flags + const kp = this.kingPos[color]; + const mirrorSide = sideBoard[0][kp[0]][kp[1]] != VariantRules.EMPTY ? 1 : 2; let saveBoard = this.board; - this.board = sideBoard; - let res = this.isAttacked(this.kingPos[color], this.getOppCol(color)); + this.board = sideBoard[mirrorSide-1]; + let res = this.isAttacked(kp, this.getOppCol(color)); this.board = saveBoard; - this.undo(move); + this.undoSide(move, sideBoard); return res; } @@ -156,7 +233,10 @@ class AliceRules extends ChessRules { this.play(move); const color = this.turn; //opponent - let sideBoard = this.getBoardOfPiece(this.kingPos[color]); + const pieces = Object.keys(VariantRules.ALICE_CODES); + const kp = this.kingPos[color]; + const mirrorSide = (pieces.includes(this.getPiece(kp[0],kp[1])) ? 1 : 2); + let sideBoard = this.getSideBoard(mirrorSide); let saveBoard = this.board; this.board = sideBoard; let res = this.isAttacked(this.kingPos[color], this.getOppCol(color)) @@ -189,35 +269,13 @@ class AliceRules extends ChessRules this.kingPos[c] = [move.start.x, move.start.y]; } - getNotation(move) - { - if (move.appear.length == 2 && move.appear[0].p == VariantRules.KING) - { - if (move.end.y < move.start.y) - return "0-0-0"; - else - return "0-0"; - } - - const finalSquare = - String.fromCharCode(97 + move.end.y) + (VariantRules.size[0]-move.end.x); - const piece = this.getPiece(move.start.x, move.start.y); - - // Piece or pawn movement - let notation = piece.toUpperCase() + - (move.vanish.length > move.appear.length ? "x" : "") + finalSquare; - if (['s','p'].includes(piece) && !['s','p'].includes(move.appear[0].p)) - { - // Promotion - notation += "=" + move.appear[0].p.toUpperCase(); - } - return notation; - } - checkGameEnd() { + const pieces = Object.keys(VariantRules.ALICE_CODES); const color = this.turn; - let sideBoard = this.getBoardOfPiece(this.kingPos[color]); + const kp = this.kingPos[color]; + const mirrorSide = (pieces.includes(this.getPiece(kp[0],kp[1])) ? 1 : 2); + let sideBoard = this.getSideBoard(mirrorSide); let saveBoard = this.board; this.board = sideBoard; let res = "*"; @@ -245,4 +303,33 @@ class AliceRules extends ChessRules 'l': 1000 }; } + + getNotation(move) + { + if (move.appear.length == 2 && move.appear[0].p == VariantRules.KING) + { + if (move.end.y < move.start.y) + return "0-0-0"; + else + return "0-0"; + } + + const finalSquare = + String.fromCharCode(97 + move.end.y) + (VariantRules.size[0]-move.end.x); + const piece = this.getPiece(move.start.x, move.start.y); + + const captureMark = (move.vanish.length > move.appear.length ? "x" : ""); + let pawnMark = ""; + if (["p","s"].includes(piece) && captureMark.length == 1) + pawnMark = String.fromCharCode(97 + move.start.y); //start column + + // Piece or pawn movement + let notation = piece.toUpperCase() + pawnMark + captureMark + finalSquare; + if (['s','p'].includes(piece) && !['s','p'].includes(move.appear[0].p)) + { + // Promotion + notation += "=" + move.appear[0].p.toUpperCase(); + } + return notation; + } }