X-Git-Url: https://git.auder.net/?p=vchess.git;a=blobdiff_plain;f=public%2Fjavascripts%2Fvariants%2FUltima.js;h=c98822dcbf0e85aa68889faf0f4c338194dd79ef;hp=18afe40268efffe4c38a9c018d4664cc0bbb4ab8;hb=9d218497ab97bc0e94ec4c1f0a40cf02df3ea0d4;hpb=7688bf7781d10bdf7db2ff558a35852bebcaae53 diff --git a/public/javascripts/variants/Ultima.js b/public/javascripts/variants/Ultima.js index 18afe402..c98822dc 100644 --- a/public/javascripts/variants/Ultima.js +++ b/public/javascripts/variants/Ultima.js @@ -53,13 +53,13 @@ class UltimaRules extends ChessRules getPotentialMovesFrom([x,y]) { // Pre-check: is thing on this square immobilized? - // In this case add potential suicide as a move "taking the immobilizer" const piece = this.getPiece(x,y); const color = this.getColor(x,y); const oppCol = this.getOppCol(color); const V = VariantRules; const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]); const [sizeX,sizeY] = V.size; + outerLoop: for (let step of adjacentSteps) { const [i,j] = [x+step[0],y+step[1]]; @@ -67,15 +67,23 @@ class UltimaRules extends ChessRules && this.getColor(i,j) == oppCol) { const oppPiece = this.getPiece(i,j); - if (oppPiece == V.IMMOBILIZER - || (oppPiece == V.BISHOP && piece == V.IMMOBILIZER)) + if (oppPiece == V.BISHOP && piece == V.IMMOBILIZER) + return []; + if (oppPiece == V.IMMOBILIZER && ![V.BISHOP,V.IMMOBILIZER].includes(piece)) { - return [ new Move({ - appear: [], - vanish: [{x:x,y:y,p:piece,c:color}], - start: {x:x,y:y}, - end: {x:i,y:j} - }) ]; + // Moving is impossible only if this immobilizer is not neutralized + for (let step2 of adjacentSteps) + { + const [i2,j2] = [i+step2[0],j+step2[1]]; + if (i2>=0 && i2=0 && j2 { + if (!!byChameleon && m.start.x!=m.end.x && m.start.y!=m.end.y) + return; //chameleon not moving as pawn + // Try capturing in every direction + for (let step of steps) + { + const sq2 = [m.end.x+2*step[0],m.end.y+2*step[1]]; + if (sq2[0]>=0 && sq2[0]=0 && sq2[1] { - if (m - }); + this.addPawnCaptures(moves); + return moves; } - // Coordinator - getPotentialRookMoves(sq) + addRookCaptures(moves, byChameleon) { - const color = this.getColor(sq); + const color = this.turn; const oppCol = this.getOppCol(color); const kp = this.kingPos[color]; - let moves = super.getPotentialQueenMoves(sq); moves.forEach(m => { // Check piece-king rectangle (if any) corners for enemy pieces if (m.end.x == kp[0] || m.end.y == kp[1]) @@ -145,27 +188,42 @@ class UltimaRules extends ChessRules { if (this.board[i][j] != VariantRules.EMPTY && this.getColor(i,j) == oppCol) { - m.vanish.push( new PiPo({ - x:i, - y:j, - p:this.getPiece(i,j), - c:oppCol - }) ); + const piece = this.getPiece(i,j); + if (!byChameleon || piece == VariantRules.ROOK) + { + m.vanish.push( new PiPo({ + x:i, + y:j, + p:piece, + c:oppCol + }) ); + } } } }); + } + + // Coordinator + getPotentialRookMoves(sq) + { + let moves = super.getPotentialQueenMoves(sq); + this.addRookCaptures(moves); return moves; } // Long-leaper - getPotentialKnightMoves([x,y]) + getKnightCaptures(startSquare, byChameleon) { - let moves = super.getPotentialQueenMoves(sq); // Look in every direction for captures const V = VariantRules; const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]); const [sizeX,sizeY] = V.size; - const color = this.getColor(x,y); + const color = this.turn; + const oppCol = this.getOppCol(color); + let moves = []; + const [x,y] = [startSquare[0],startSquare[1]]; + const piece = this.getPiece(x,y); //might be a chameleon! + outerLoop: for (let step of steps) { let [i,j] = [x+step[0], y+step[1]]; @@ -174,44 +232,118 @@ class UltimaRules extends ChessRules i += step[0]; j += step[1]; } - if (i<0 && i>=sizeX || j<0 || j>=sizeY || this.getColor(i,j)==color) + if (i<0 || i>=sizeX || j<0 || j>=sizeY || this.getColor(i,j)==color + || (!!byChameleon && this.getPiece(i,j)!=V.KNIGHT)) + { continue; - // Found an enemy piece: potential capture (if empty space behind) - // So, while we find enemy pieces + space in this direction, add captures! - i += step[0]; - j += step[1]; - while ( ) //TODO: finish........ + } + // last(thing), cur(thing) : stop if "cur" is our color, or beyond board limits, + // or if "last" isn't empty and cur neither. Otherwise, if cur is empty then + // add move until cur square; if cur is occupied then stop if !!byChameleon and + // the square not occupied by a leaper. + let last = [i,j]; + let cur = [i+step[0],j+step[1]]; + let vanished = [ new PiPo({x:x,y:y,c:color,p:piece}) ]; + while (cur[0]>=0 && cur[0]=0 && cur[1] { + const key = m.end.x + sizeX * m.end.y; + if (!mergedMoves[key]) + mergedMoves[key] = m; + else + { + for (let i=1; i { moves.push(mergedMoves[k]); }); + return moves; + } + + // Withdrawer + addQueenCaptures(moves, byChameleon) + { + if (moves.length == 0) + return; + const [x,y] = [moves[0].start.x,moves[0].start.y]; const V = VariantRules; const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]); let capturingDirections = []; - const color = this.getColor(x,y); + const color = this.turn; const oppCol = this.getOppCol(color); + const [sizeX,sizeY] = V.size; adjacentSteps.forEach(step => { const [i,j] = [x+step[0],y+step[1]]; - if (this.board[i][j] != V.EMPTY && this.getColor(i,j) == oppCol) + if (i>=0 && i=0 && j { const step = [ m.end.x!=x ? (m.end.x-x)/Math.abs(m.end.x-x) : 0, m.end.y!=y ? (m.end.y-y)/Math.abs(m.end.y-y) : 0 ]; - // NOTE: includes() function does not work on complex array elements + // NOTE: includes() and even _.isEqual() functions fail... // TODO: this test should be done only once per direction - if (capturingDirection.some(dir => _.isEqual(dir, step))) + if (capturingDirections.some(dir => + { return (dir[0]==-step[0] && dir[1]==-step[1]); })) { const [i,j] = [x-step[0],y-step[1]]; m.vanish.push(new PiPo({ @@ -224,8 +356,16 @@ class UltimaRules extends ChessRules }); } + getPotentialQueenMoves(sq) + { + let moves = super.getPotentialQueenMoves(sq); + this.addQueenCaptures(moves); + return moves; + } + getPotentialImmobilizerMoves(sq) { + // Immobilizer doesn't capture return super.getPotentialQueenMoves(sq); } @@ -236,42 +376,34 @@ class UltimaRules extends ChessRules V.steps[V.ROOK].concat(V.steps[V.BISHOP]), "oneStep"); } - // isAttacked() is OK because the immobilizer doesn't take - - isAttackedByPawn([x,y], colors) - { - // Square (x,y) must be surrounded by two enemy pieces, - // and one of them at least should be a pawn - return false; - } - - isAttackedByRook(sq, colors) + atLeastOneMove() { - // Enemy king must be on same file and a rook on same row (or reverse) + if (this.kingPos[this.turn][0] < 0) + return false; + return super.atLeastOneMove(); } - isAttackedByKnight(sq, colors) + underCheck(move) { - // Square (x,y) must be on same line as a knight, - // and there must be empty square(s) behind. + return false; //there is no check } - isAttackedByBishop(sq, colors) + getCheckSquares(move) { - // switch on piece nature on square sq: a chameleon attack as this piece - // ==> call the appropriate isAttackedBy... (exception of immobilizers) - // Other exception: a chameleon cannot attack a chameleon (seemingly...) - } - - isAttackedByQueen(sq, colors) - { - // Square (x,y) must be adjacent to a queen, and the queen must have - // some free space in the opposite direction from (x,y) + const c = this.getOppCol(this.turn); //opponent + const saveKingPos = this.kingPos[c]; //king might be taken + this.play(move); + // The only way to be "under check" is to have lost the king (thus game over) + let res = this.kingPos[c][0] < 0 + ? [ JSON.parse(JSON.stringify(saveKingPos)) ] + : [ ]; + this.undo(move); + return res; } updateVariables(move) { - // Just update king position + // Just update king(s) position(s) const piece = this.getPiece(move.start.x,move.start.y); const c = this.getColor(move.start.x,move.start.y); if (piece == VariantRules.KING && move.appear.length > 0) @@ -279,6 +411,42 @@ class UltimaRules extends ChessRules this.kingPos[c][0] = move.appear[0].x; this.kingPos[c][1] = move.appear[0].y; } + // Does this move takes opponent's king? + const oppCol = this.getOppCol(c); + for (let i=1; i