X-Git-Url: https://git.auder.net/img/rock_paper_scissors_lizard_spock.gif?a=blobdiff_plain;f=public%2Fjavascripts%2Fvariants%2FAlice.js;h=4d105069e1cb55b1773723b9dcadd04c8cf04859;hb=a4cf093aa57faa18751e4978c1512558cce3417a;hp=db0881e29b863fae99d0b7215fcf0a95b7a27e62;hpb=0cd8f2bdfe04a0bd880ee48ef2dcce24728536ee;p=vchess.git diff --git a/public/javascripts/variants/Alice.js b/public/javascripts/variants/Alice.js index db0881e2..4d105069 100644 --- a/public/javascripts/variants/Alice.js +++ b/public/javascripts/variants/Alice.js @@ -1,86 +1,169 @@ -class AliceRules extends ChessRUles +class AliceRules extends ChessRules { - // TODO: more general double correspondance normal <--> alice static get ALICE_PIECES() { - return ['s','t','u','c','o','l']; //king is 'l' + return { + 's': 'p', + 't': 'q', + 'u': 'r', + 'c': 'b', + 'o': 'n', + 'l': 'k', + }; + } + static get ALICE_CODES() + { + return { + 'p': 's', + 'q': 't', + 'r': 'u', + 'b': 'c', + 'n': 'o', + 'k': 'l', + }; } static getPpath(b) { - return (this.ALICE_PIECES.includes(b[1]) ? "Alice/" : "") + b; + return (Object.keys(this.ALICE_PIECES).includes(b[1]) ? "Alice/" : "") + b; } - getPotentialMovesFrom([x,y]) + getBoardOfPiece([x,y]) { - // Build board1+board2 from complete board - let board1 = doubleArray(sizeX, sizeY, ""); - let board2 = doubleArray(sizeX, sizeY, ""); - const [sizeX,sizeY] = variantRules.size; + 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, ""); for (let i=0; i Should be OK as is. + getPotentialMovesFrom([x,y]) + { + let sideBoard = this.getBoardOfPiece([x,y]); + // Search valid moves on sideBoard + let saveBoard = this.board; + this.board = sideBoard; + let moves = super.getPotentialMovesFrom([x,y]); this.board = saveBoard; // Finally filter impossible moves - - return moves; + const mirrorSide = (Object.keys(VariantRules.ALICE_CODES).includes(this.getPiece(x,y)) ? 1 : 2); + return moves.filter(m => { + if (m.appear.length == 2) //castle + { + // If appear[i] not in vanish array, then must be empty square on other board + m.appear.forEach(psq => { + if (this.board[psq.x][psq.y] != VariantRules.EMPTY && + ![m.vanish[0].y,m.vanish[1].y].includes(psq.y)) + { + return false; + } + }); + } + else if (this.board[m.end.x][m.end.y] != VariantRules.EMPTY) + { + // 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))) + { + return false; + } + } + // If the move is computed on board1, m.appear change for Alice pieces. + if (mirrorSide==1) + { + m.appear.forEach(psq => { //forEach: castling taken into account + psq.p = VariantRules.ALICE_CODES[psq.p]; //goto board2 + }); + } + else //move on board2: mark vanishing piece as Alice + m.vanish[0].p = VariantRules.ALICE_CODES[m.vanish[0].p] + return true; + }); } underCheck(move) { - // 1 where is king ? if board1 then build it, if board2 then build it. then check. const color = this.turn; this.play(move); + let sideBoard = this.getBoardOfPiece(this.kingPos[color]); + let saveBoard = this.board; + this.board = sideBoard; let res = this.isAttacked(this.kingPos[color], this.getOppCol(color)); + this.board = saveBoard; this.undo(move); return res; } - // TODO also: - //getCheckSquares(move) - - // TODO: pieces change side! - static PlayOnBoard(board, move) + getCheckSquares(move) { - for (let psq of move.vanish) - board[psq.x][psq.y] = VariantRules.EMPTY; - for (let psq of move.appear) - board[psq.x][psq.y] = psq.c + psq.p; + this.play(move); + const color = this.turn; //opponent + let sideBoard = this.getBoardOfPiece(this.kingPos[color]); + let saveBoard = this.board; + this.board = sideBoard; + let res = this.isAttacked(this.kingPos[color], this.getOppCol(color)) + ? [ JSON.parse(JSON.stringify(this.kingPos[color])) ] + : [ ]; + this.board = saveBoard; + this.undo(move); + return res; } - static UndoOnBoard(board, move) + + getNotation(move) { - for (let psq of move.appear) - board[psq.x][psq.y] = VariantRules.EMPTY; - for (let psq of move.vanish) - board[psq.x][psq.y] = psq.c + psq.p; + 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 color = this.turn; - // No valid move: stalemate or checkmate? - // TODO: here also, need to build the board with king on it + let sideBoard = this.getBoardOfPiece(this.kingPos[color]); + let saveBoard = this.board; + this.board = sideBoard; + let res = "*"; if (!this.isAttacked(this.kingPos[color], this.getOppCol(color))) - return "1/2"; - // OK, checkmate - return color == "w" ? "0-1" : "1-0"; + res = "1/2"; + else + res = (color == "w" ? "0-1" : "1-0"); + this.board = saveBoard; + return res; } }