X-Git-Url: https://git.auder.net/?p=vchess.git;a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FDynamo.js;h=9b29e3ca45f91c16f017fa193ab5b9d77e0950f0;hp=9c0d08013c437205a872b3f5491eb37dcefe4fc2;hb=9aeba28ad5f7417aaae64b3a863a7dde388dffe5;hpb=cfceecbafc550838f9ec425d3695d0b0d208920e diff --git a/client/src/variants/Dynamo.js b/client/src/variants/Dynamo.js index 9c0d0801..9b29e3ca 100644 --- a/client/src/variants/Dynamo.js +++ b/client/src/variants/Dynamo.js @@ -2,7 +2,8 @@ import { ChessRules, Move, PiPo } from "@/base_rules"; import { randInt } from "@/utils/alea"; export class DynamoRules extends ChessRules { - // TODO: later, allow to push out pawns on a and h files + + // TODO? later, allow to push out pawns on a and h files static get HasEnpassant() { return false; } @@ -43,7 +44,6 @@ export class DynamoRules extends ChessRules { }); this.amoves.push(move); } - this.subTurn = 1; // Stack "first moves" (on subTurn 1) to merge and check opposite moves this.firstMove = []; } @@ -157,9 +157,8 @@ export class DynamoRules extends ChessRules { return [dx / divisor, dy / divisor]; } - // There was something on x2,y2, maybe our color, pushed/pulled. - // Also, the pushed/pulled piece must exit the board. - isAprioriValidExit([x1, y1], [x2, y2], color2) { + // There was something on x2,y2, maybe our color, pushed or (self)pulled + isAprioriValidExit([x1, y1], [x2, y2], color2, piece2) { const color1 = this.getColor(x1, y1); const pawnShift = (color1 == 'w' ? -1 : 1); const lastRank = (color1 == 'w' ? 0 : 7); @@ -174,13 +173,17 @@ export class DynamoRules extends ChessRules { } return !V.OnBoard(i, j); }; - switch (this.getPiece(x1, y1)) { + switch (piece2 || this.getPiece(x1, y1)) { case V.PAWN: return ( x1 + pawnShift == x2 && ( (color1 == color2 && x2 == lastRank && y1 == y2) || - (color1 != color2 && deltaY == 1 && !V.OnBoard(x2, 2 * y2 - y1)) + ( + color1 != color2 && + deltaY == 1 && + !V.OnBoard(2 * x2 - x1, 2 * y2 - y1) + ) ) ); case V.ROOK: @@ -208,15 +211,34 @@ export class DynamoRules extends ChessRules { return false; } + isAprioriValidVertical([x1, y1], x2) { + const piece = this.getPiece(x1, y1); + const deltaX = Math.abs(x1 - x2); + const startRank = (this.getColor(x1, y1) == 'w' ? 6 : 1); + return ( + [V.QUEEN, V.ROOK].includes(piece) || + ( + [V.KING, V.PAWN].includes(piece) && + ( + deltaX == 1 || + (deltaX == 2 && piece == V.PAWN && x1 == startRank) + ) + ) + ); + } + // NOTE: for pushes, play the pushed piece first. // for pulls: play the piece doing the action first // NOTE: to push a piece out of the board, make it slide until its king getPotentialMovesFrom([x, y]) { const color = this.turn; + const sqCol = this.getColor(x, y); + const pawnShift = (color == 'w' ? -1 : 1); + const pawnStartRank = (color == 'w' ? 6 : 1); + const getMoveHash = (m) => { + return V.CoordsToSquare(m.start) + V.CoordsToSquare(m.end); + }; if (this.subTurn == 1) { - const getMoveHash = (m) => { - return V.CoordsToSquare(m.start) + V.CoordsToSquare(m.end); - }; const addMoves = (dir, nbSteps) => { const newMoves = this.getMovesInDirection([x, y], [-dir[0], -dir[1]], nbSteps) @@ -226,7 +248,7 @@ export class DynamoRules extends ChessRules { }; // Free to play any move (if piece of my color): let moves = - this.getColor(x, y) == color + sqCol == color ? super.getPotentialMovesFrom([x, y]) : []; // There may be several suicide moves: keep only one @@ -239,8 +261,6 @@ export class DynamoRules extends ChessRules { } return true; }); - const pawnShift = (color == 'w' ? -1 : 1); - const pawnStartRank = (color == 'w' ? 6 : 1); // Structure to avoid adding moves twice (can be action & move) let movesHash = {}; moves.forEach(m => { movesHash[getMoveHash(m)] = true; }); @@ -276,13 +296,12 @@ export class DynamoRules extends ChessRules { deltaX <= 2 && deltaY <= 1 ) { - const pColor = this.getColor(x, y); - if (pColor == color && deltaY == 0) { + if (sqCol == color && deltaY == 0) { // Pushed forward const maxSteps = (i == pawnStartRank && deltaX == 1 ? 2 : 1); addMoves(step, maxSteps); } - else if (pColor != color && deltaY == 1 && deltaX == 1) + else if (sqCol != color && deltaY == 1 && deltaX == 1) // Pushed diagonally addMoves(step, 1); } @@ -307,16 +326,18 @@ export class DynamoRules extends ChessRules { } // If subTurn == 2 then we should have a first move, // which restrict what we can play now: only in the first move direction - // NOTE: no need for knight or pawn checks, because the move will be - // naturally limited in those cases. const L = this.firstMove.length; const fm = this.firstMove[L-1]; - if (fm.appear.length == 2 && fm.vanish.length == 2) - // Castle: no real move playable then. + if ( + (fm.appear.length == 2 && fm.vanish.length == 2) || + (fm.vanish[0].c == sqCol && sqCol != color) + ) { + // Castle or again opponent color: no move playable then. return []; - if (fm.appear.length == 0) { - // Piece at subTurn 1 just exited the board. - // Can I be a piece which caused the exit? + } + const piece = this.getPiece(x, y); + const getPushExit = () => { + // Piece at subTurn 1 exited: can I have caused the exit? if ( this.isAprioriValidExit( [x, y], @@ -327,17 +348,83 @@ export class DynamoRules extends ChessRules { // Seems so: const dir = this.getNormalizedDirection( [fm.start.x - x, fm.start.y - y]); - return this.getMovesInDirection([x, y], dir); + const nbSteps = + [V.PAWN, V.KING, V.KNIGHT].includes(piece) + ? 1 + : null; + return this.getMovesInDirection([x, y], dir, nbSteps); } + return []; } - else { + const getPushMoves = () => { + // Piece from subTurn 1 is still on board: const dirM = this.getNormalizedDirection( [fm.end.x - fm.start.x, fm.end.y - fm.start.y]); const dir = this.getNormalizedDirection( [fm.start.x - x, fm.start.y - y]); // Normalized directions should match if (dir[0] == dirM[0] && dir[1] == dirM[1]) { - // And nothing should stand between [x, y] and the square fm.start + // We don't know if first move is a pushed piece or normal move, + // so still must check if the push is valid. + const deltaX = Math.abs(fm.start.x - x); + const deltaY = Math.abs(fm.start.y - y); + switch (piece) { + case V.PAWN: + if (x == pawnStartRank) { + if ( + (fm.start.x - x) * pawnShift < 0 || + deltaX >= 3 || + deltaY >= 2 || + (fm.vanish[0].c == color && deltaY > 0) || + (fm.vanish[0].c != color && deltaY == 0) || + Math.abs(fm.end.x - fm.start.x) > deltaX || + fm.end.y - fm.start.y != fm.start.y - y + ) { + return []; + } + } + else { + if ( + fm.start.x - x != pawnShift || + deltaY >= 2 || + (fm.vanish[0].c == color && deltaY == 1) || + (fm.vanish[0].c != color && deltaY == 0) || + fm.end.x - fm.start.x != pawnShift || + fm.end.y - fm.start.y != fm.start.y - y + ) { + return []; + } + } + break; + case V.KNIGHT: + if ( + (deltaX + deltaY != 3 || (deltaX == 0 && deltaY == 0)) || + (fm.end.x - fm.start.x != fm.start.x - x) || + (fm.end.y - fm.start.y != fm.start.y - y) + ) { + return []; + } + break; + case V.KING: + if ( + (deltaX >= 2 || deltaY >= 2) || + (fm.end.x - fm.start.x != fm.start.x - x) || + (fm.end.y - fm.start.y != fm.start.y - y) + ) { + return []; + } + break; + case V.BISHOP: + if (deltaX != deltaY) return []; + break; + case V.ROOK: + if (deltaX != 0 && deltaY != 0) return []; + break; + case V.QUEEN: + if (deltaX != deltaY && deltaX != 0 && deltaY != 0) return []; + break; + } + // Nothing should stand between [x, y] and the square fm.start let [i, j] = [x + dir[0], y + dir[1]]; while ( (i != fm.start.x || j != fm.start.y) && @@ -349,12 +436,97 @@ export class DynamoRules extends ChessRules { if (i == fm.start.x && j == fm.start.y) return this.getMovesInDirection([x, y], dir); } + return []; + } + const getPullExit = () => { + // Piece at subTurn 1 exited: can I be pulled? + // Note: kings cannot suicide, so fm.vanish[0].p is not KING. + // Could be PAWN though, if a pawn was pushed out of board. + if ( + fm.vanish[0].p != V.PAWN && //pawns cannot pull + this.isAprioriValidExit( + [x, y], + [fm.start.x, fm.start.y], + fm.vanish[0].c, + fm.vanish[0].p + ) + ) { + // Seems so: + const dir = this.getNormalizedDirection( + [fm.start.x - x, fm.start.y - y]); + const nbSteps = (fm.vanish[0].p == V.KNIGHT ? 1 : null); + return this.getMovesInDirection([x, y], dir, nbSteps); + } + return []; + }; + const getPullMoves = () => { + if (fm.vanish[0].p == V.PAWN) + // pawns cannot pull + return []; + const dirM = this.getNormalizedDirection( + [fm.end.x - fm.start.x, fm.end.y - fm.start.y]); + const dir = this.getNormalizedDirection( + [fm.start.x - x, fm.start.y - y]); + // Normalized directions should match + if (dir[0] == dirM[0] && dir[1] == dirM[1]) { + // Am I at the right distance? + const deltaX = Math.abs(x - fm.start.x); + const deltaY = Math.abs(y - fm.start.y); + if ( + (fm.vanish[0].p == V.KING && (deltaX > 1 || deltaY > 1)) || + (fm.vanish[0].p == V.KNIGHT && + (deltaX + deltaY != 3 || deltaX == 0 || deltaY == 0)) + ) { + return []; + } + // Nothing should stand between [x, y] and the square fm.start + let [i, j] = [x + dir[0], y + dir[1]]; + while ( + (i != fm.start.x || j != fm.start.y) && + this.board[i][j] == V.EMPTY + ) { + i += dir[0]; + j += dir[1]; + } + if (i == fm.start.x && j == fm.start.y) + return this.getMovesInDirection([x, y], dir); + } + return []; + }; + if (fm.vanish[0].c != color) { + // Only possible action is a push: + if (fm.appear.length == 0) return getPushExit(); + return getPushMoves(); + } + else if (sqCol != color) { + // Only possible action is a pull, considering moving piece abilities + if (fm.appear.length == 0) return getPullExit(); + return getPullMoves(); + } + else { + // My color + my color: both actions possible + // Structure to avoid adding moves twice (can be action & move) + let movesHash = {}; + if (fm.appear.length == 0) { + const pushes = getPushExit(); + pushes.forEach(m => { movesHash[getMoveHash(m)] = true; }); + return ( + pushes.concat(getPullExit().filter(m => !movesHash[getMoveHash(m)])) + ); + } + const pushes = getPushMoves(); + pushes.forEach(m => { movesHash[getMoveHash(m)] = true; }); + return ( + pushes.concat(getPullMoves().filter(m => !movesHash[getMoveHash(m)])) + ); } return []; } getSlideNJumpMoves([x, y], steps, oneStep) { let moves = []; + const c = this.getColor(x, y); + const piece = this.getPiece(x, y); outerLoop: for (let step of steps) { let i = x + step[0]; let j = y + step[1]; @@ -370,9 +542,7 @@ export class DynamoRules extends ChessRules { } else { // Add potential board exit (suicide), except for the king - const piece = this.getPiece(x, y); if (piece != V.KING) { - const c = this.getColor(x, y); moves.push({ start: { x: x, y: y}, end: { x: this.kingPos[c][0], y: this.kingPos[c][1] }, @@ -395,7 +565,6 @@ export class DynamoRules extends ChessRules { // Does m2 un-do m1 ? (to disallow undoing actions) oppositeMoves(m1, m2) { const isEqual = (av1, av2) => { - // Precondition: av1 and av2 length = 2 for (let av of av1) { const avInAv2 = av2.find(elt => { return ( @@ -409,11 +578,12 @@ export class DynamoRules extends ChessRules { } return true; }; + // All appear and vanish arrays must have the same length + const mL = m1.appear.length; return ( - m1.appear.length == 2 && - m2.appear.length == 2 && - m1.vanish.length == 2 && - m2.vanish.length == 2 && + m2.appear.length == mL && + m1.vanish.length == mL && + m2.vanish.length == mL && isEqual(m1.appear, m2.vanish) && isEqual(m1.vanish, m2.appear) ); @@ -429,6 +599,7 @@ export class DynamoRules extends ChessRules { filterValid(moves) { const color = this.turn; + const La = this.amoves.length; if (this.subTurn == 1) { return moves.filter(m => { // A move is valid either if it doesn't result in a check, @@ -436,13 +607,17 @@ export class DynamoRules extends ChessRules { // (not undoing a potential move + action of the opponent) this.play(m); let res = this.underCheck(color); - if (res) { + let isOpposite = La > 0 && this.oppositeMoves(this.amoves[La-1], m); + if (res || isOpposite) { const moves2 = this.getAllPotentialMoves(); for (let m2 of moves2) { this.play(m2); const res2 = this.underCheck(color); + const amove = this.getAmove(m, m2); + isOpposite = + La > 0 && this.oppositeMoves(this.amoves[La-1], amove); this.undo(m2); - if (!res2) { + if (!res2 && !isOpposite) { res = false; break; } @@ -452,9 +627,8 @@ export class DynamoRules extends ChessRules { return !res; }); } - const Lf = this.firstMove.length; - const La = this.amoves.length; if (La == 0) return super.filterValid(moves); + const Lf = this.firstMove.length; return ( super.filterValid( moves.filter(m => { @@ -509,19 +683,41 @@ export class DynamoRules extends ChessRules { } isAttackedByPawn([x, y], color) { - const lastRank = (color == 'w' ? 0 : 7); - if (x != lastRank) - // The king can be pushed out by a pawn only on last rank - return false; + // The king can be pushed out by a pawn on last rank or near the edge const pawnShift = (color == "w" ? 1 : -1); for (let i of [-1, 1]) { if ( - y + i >= 0 && - y + i < V.size.y && + V.OnBoard(x + pawnShift, y + i) && + this.board[x + pawnShift][y + i] != V.EMPTY && this.getPiece(x + pawnShift, y + i) == V.PAWN && this.getColor(x + pawnShift, y + i) == color ) { - return true; + if (!V.OnBoard(x - pawnShift, y - i)) return true; + } + } + return false; + } + + static OnTheEdge(x, y) { + return (x == 0 || x == 7 || y == 0 || y == 7); + } + + isAttackedByKing([x, y], color) { + // Attacked if I'm on the edge and the opponent king just next, + // but not on the edge. + if (V.OnTheEdge(x, y)) { + for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) { + const [i, j] = [x + step[0], y + step[1]]; + if ( + V.OnBoard(i, j) && + !V.OnTheEdge(i, j) && + this.board[i][j] != V.EMPTY && + this.getPiece(i, j) == V.KING + // NOTE: since only one king of each color, and (x, y) is occupied + // by our king, no need to check other king's color. + ) { + return true; + } } } return false; @@ -543,49 +739,79 @@ export class DynamoRules extends ChessRules { return potentialMoves; } - getCurrentScore() { - if (this.subTurn == 2) - // Move not over - return "*"; - return super.getCurrentScore(); + getEmptyMove() { + return new Move({ + start: { x: -1, y: -1 }, + end: { x: -1, y: -1 }, + appear: [], + vanish: [] + }); } doClick(square) { - // If subTurn == 2 && square is empty && !underCheck, + // A click to promote a piece on subTurn 2 would trigger this. + // For now it would then return [NaN, NaN] because surrounding squares + // have no IDs in the promotion modal. TODO: improve this? + if (isNaN(square[0])) return null; + // If subTurn == 2 && square is empty && !underCheck && !isOpposite, // then return an empty move, allowing to "pass" subTurn2 + const La = this.amoves.length; + const Lf = this.firstMove.length; if ( this.subTurn == 2 && this.board[square[0]][square[1]] == V.EMPTY && - !this.underCheck(this.turn) + !this.underCheck(this.turn) && + (La == 0 || !this.oppositeMoves(this.amoves[La-1], this.firstMove[Lf-1])) ) { - return { - start: { x: -1, y: -1 }, - end: { x: -1, y: -1 }, - appear: [], - vanish: [] - }; + return this.getEmptyMove(); } return null; } play(move) { - move.flags = JSON.stringify(this.aggregateFlags()); - V.PlayOnBoard(this.board, move); - if (this.subTurn == 2) { + const color = this.turn; + move.subTurn = this.subTurn; //for undo + const gotoNext = (mv) => { const L = this.firstMove.length; - this.amoves.push(this.getAmove(this.firstMove[L-1], move)); - this.turn = V.GetOppCol(this.turn); + this.amoves.push(this.getAmove(this.firstMove[L-1], mv)); + this.turn = V.GetOppCol(color); + this.subTurn = 1; this.movesCount++; + }; + move.flags = JSON.stringify(this.aggregateFlags()); + V.PlayOnBoard(this.board, move); + if (this.subTurn == 2) gotoNext(move); + else { + this.subTurn = 2; + this.firstMove.push(move); + this.toNewKingPos(move); + if ( + // Condition is true on empty arrays: + this.getAllPotentialMoves().every(m => { + V.PlayOnBoard(this.board, m); + this.toNewKingPos(m); + const res = this.underCheck(color); + V.UndoOnBoard(this.board, m); + this.toOldKingPos(m); + return res; + }) + ) { + // No valid move at subTurn 2 + gotoNext(this.getEmptyMove()); + } + this.toOldKingPos(move); } - else this.firstMove.push(move); - this.subTurn = 3 - this.subTurn; this.postPlay(move); } - postPlay(move) { - if (move.start.x < 0) return; + toNewKingPos(move) { for (let a of move.appear) if (a.p == V.KING) this.kingPos[a.c] = [a.x, a.y]; + } + + postPlay(move) { + if (move.start.x < 0) return; + this.toNewKingPos(move); this.updateCastleFlags(move); } @@ -604,15 +830,16 @@ export class DynamoRules extends ChessRules { this.disaggregateFlags(JSON.parse(move.flags)); V.UndoOnBoard(this.board, move); if (this.subTurn == 1) { + this.amoves.pop(); this.turn = V.GetOppCol(this.turn); this.movesCount--; } - else this.firstMove.pop(); - this.subTurn = 3 - this.subTurn; - this.postUndo(move); + if (move.subTurn == 1) this.firstMove.pop(); + this.subTurn = move.subTurn; + this.toOldKingPos(move); } - postUndo(move) { + toOldKingPos(move) { // (Potentially) Reset king position for (let v of move.vanish) if (v.p == V.KING) this.kingPos[v.c] = [v.x, v.y]; @@ -677,4 +904,5 @@ export class DynamoRules extends ChessRules { return initialSquare + "R"; return move.appear[0].p.toUpperCase() + initialSquare + finalSquare; } + };