X-Git-Url: https://git.auder.net/?p=vchess.git;a=blobdiff_plain;f=client%2Fsrc%2Fvariants%2FEightpieces.js;h=fa80824bef1fddef326a51e7e15017531c944b2a;hp=c83cf5ed48a5b2576ddd1cc3d4766b10d12da5af;hb=d54f6261c9e30f4eabb402ad301dd5c5e40fb656;hpb=afbf3ca7151ef15a9e579b0f913683ab212396c4 diff --git a/client/src/variants/Eightpieces.js b/client/src/variants/Eightpieces.js index c83cf5ed..fa80824b 100644 --- a/client/src/variants/Eightpieces.js +++ b/client/src/variants/Eightpieces.js @@ -2,7 +2,7 @@ import { ArrayFun } from "@/utils/array"; import { randInt } from "@/utils/alea"; import { ChessRules, PiPo, Move } from "@/base_rules"; -export const VariantRules = class EightpiecesRules extends ChessRules { +export class EightpiecesRules extends ChessRules { static get JAILER() { return "j"; } @@ -13,8 +13,9 @@ export const VariantRules = class EightpiecesRules extends ChessRules { return "l"; } - static get PIECES() { - return ChessRules.PIECES.concat([V.JAILER, V.SENTRY, V.LANCER]); + static get IMAGE_EXTENSION() { + // Temporarily, for the time SVG pieces are being designed: + return ".png"; } // Lancer directions *from white perspective* @@ -31,6 +32,12 @@ export const VariantRules = class EightpiecesRules extends ChessRules { }; } + static get PIECES() { + return ChessRules.PIECES + .concat([V.JAILER, V.SENTRY]) + .concat(Object.keys(V.LANCER_DIRS)); + } + getPiece(i, j) { const piece = this.board[i][j].charAt(1); // Special lancer case: 8 possible orientations @@ -38,17 +45,67 @@ export const VariantRules = class EightpiecesRules extends ChessRules { return piece; } - getPpath(b) { - if ([V.JAILER, V.SENTRY].concat(Object.keys(V.LANCER_DIRS)).includes(b[1])) - return "Eightpieces/" + b; - return b; + getPpath(b, color, score, orientation) { + if ([V.JAILER, V.SENTRY].includes(b[1])) return "Eightpieces/tmp_png/" + b; + if (Object.keys(V.LANCER_DIRS).includes(b[1])) { + if (orientation == 'w') return "Eightpieces/tmp_png/" + b; + // Find opposite direction for adequate display: + let oppDir = ''; + switch (b[1]) { + case 'c': + oppDir = 'g'; + break; + case 'g': + oppDir = 'c'; + break; + case 'd': + oppDir = 'h'; + break; + case 'h': + oppDir = 'd'; + break; + case 'e': + oppDir = 'm'; + break; + case 'm': + oppDir = 'e'; + break; + case 'f': + oppDir = 'o'; + break; + case 'o': + oppDir = 'f'; + break; + } + return "Eightpieces/tmp_png/" + b[0] + oppDir; + } + // TODO: after we have SVG pieces, remove the folder and next prefix: + return "Eightpieces/tmp_png/" + b; + } + + getPPpath(b, orientation) { + return this.getPpath(b, null, null, orientation); } static ParseFen(fen) { const fenParts = fen.split(" "); - return Object.assign(ChessRules.ParseFen(fen), { - sentrypush: fenParts[5] - }); + return Object.assign( + ChessRules.ParseFen(fen), + { sentrypush: fenParts[5] } + ); + } + + static IsGoodFen(fen) { + if (!ChessRules.IsGoodFen(fen)) return false; + const fenParsed = V.ParseFen(fen); + // 5) Check sentry push (if any) + if ( + fenParsed.sentrypush != "-" && + !fenParsed.sentrypush.match(/^([a-h][1-8],?)+$/) + ) { + return false; + } + return true; } getFen() { @@ -89,9 +146,10 @@ export const VariantRules = class EightpiecesRules extends ChessRules { static GenRandInitFen(randomness) { if (randomness == 0) // Deterministic: - return "jsfqkbnr/pppppppp/8/8/8/8/PPPPPPPP/JSDQKBNR w 0 1111 - -"; + return "jfsqkbnr/pppppppp/8/8/8/8/PPPPPPPP/JDSQKBNR w 0 ahah - -"; let pieces = { w: new Array(8), b: new Array(8) }; + let flags = ""; // Shuffle pieces on first (and last rank if randomness == 2) for (let c of ["w", "b"]) { if (c == 'b' && randomness == 1) { @@ -102,6 +160,7 @@ export const VariantRules = class EightpiecesRules extends ChessRules { pieces['w'].slice(0, lancerIdx) .concat(['g']) .concat(pieces['w'].slice(lancerIdx + 1)); + flags += flags; break; } @@ -116,7 +175,8 @@ export const VariantRules = class EightpiecesRules extends ChessRules { if (c == 'b') { // Check if white sentry is on the same color as ours. // If yes: swap bishop and sentry positions. - if ((pieces['w'].indexOf('s') - sentryPos) % 2 == 0) + // NOTE: test % 2 == 1 because there are 7 slashes. + if ((pieces['w'].indexOf('s') - sentryPos) % 2 == 1) [bishopPos, sentryPos] = [sentryPos, bishopPos]; } positions.splice(Math.max(randIndex, randIndex_tmp), 1); @@ -136,10 +196,11 @@ export const VariantRules = class EightpiecesRules extends ChessRules { positions.splice(randIndex, 1); // Rook, jailer and king positions are now almost fixed, - // only the ordering rook-> jailer or jailer->rook must be decided. + // only the ordering rook->jailer or jailer->rook must be decided. let rookPos = positions[0]; let jailerPos = positions[2]; const kingPos = positions[1]; + flags += V.CoordToColumn(rookPos) + V.CoordToColumn(jailerPos); if (Math.random() < 0.5) [rookPos, jailerPos] = [jailerPos, rookPos]; pieces[c][rookPos] = "r"; @@ -156,54 +217,15 @@ export const VariantRules = class EightpiecesRules extends ChessRules { pieces["b"].join("") + "/pppppppp/8/8/8/8/PPPPPPPP/" + pieces["w"].join("").toUpperCase() + - " w 0 1111 - -" + " w 0 " + flags + " - -" ); } - // Scan kings, rooks and jailers - scanKingsRooks(fen) { - this.INIT_COL_KING = { w: -1, b: -1 }; - this.INIT_COL_ROOK = { w: -1, b: -1 }; - this.INIT_COL_JAILER = { w: -1, b: -1 }; - this.kingPos = { w: [-1, -1], b: [-1, -1] }; - const fenRows = V.ParseFen(fen).position.split("/"); - const startRow = { 'w': V.size.x - 1, 'b': 0 }; - for (let i = 0; i < fenRows.length; i++) { - let k = 0; - for (let j = 0; j < fenRows[i].length; j++) { - switch (fenRows[i].charAt(j)) { - case "k": - this.kingPos["b"] = [i, k]; - this.INIT_COL_KING["b"] = k; - break; - case "K": - this.kingPos["w"] = [i, k]; - this.INIT_COL_KING["w"] = k; - break; - case "r": - if (i == startRow['b'] && this.INIT_COL_ROOK["b"] < 0) - this.INIT_COL_ROOK["b"] = k; - break; - case "R": - if (i == startRow['w'] && this.INIT_COL_ROOK["w"] < 0) - this.INIT_COL_ROOK["w"] = k; - break; - case "j": - if (i == startRow['b'] && this.INIT_COL_JAILER["b"] < 0) - this.INIT_COL_JAILER["b"] = k; - break; - case "J": - if (i == startRow['w'] && this.INIT_COL_JAILER["w"] < 0) - this.INIT_COL_JAILER["w"] = k; - break; - default: { - const num = parseInt(fenRows[i].charAt(j)); - if (!isNaN(num)) k += num - 1; - } - } - k++; - } - } + canTake([x1, y1], [x2, y2]) { + if (this.subTurn == 2) + // Only self captures on this subturn: + return this.getColor(x1, y1) == this.getColor(x2, y2); + return super.canTake([x1, y1], [x2, y2]); } // Is piece on square (x,y) immobilized? @@ -226,21 +248,23 @@ export const VariantRules = class EightpiecesRules extends ChessRules { // Because of the lancers, getPiece() could be wrong: // use board[x][y][1] instead (always valid). getBasicMove([sx, sy], [ex, ey], tr) { + const initColor = this.getColor(sx, sy); + const initPiece = this.board[sx][sy].charAt(1); let mv = new Move({ appear: [ new PiPo({ x: ex, y: ey, - c: tr ? tr.c : this.getColor(sx, sy), - p: tr ? tr.p : this.board[sx][sy].charAt(1) + c: tr ? tr.c : initColor, + p: tr ? tr.p : initPiece }) ], vanish: [ new PiPo({ x: sx, y: sy, - c: this.getColor(sx, sy), - p: this.board[sx][sy].charAt(1) + c: initColor, + p: initPiece }) ] }); @@ -267,19 +291,45 @@ export const VariantRules = class EightpiecesRules extends ChessRules { ); } - getPotentialMovesFrom([x,y]) { + getPotentialMovesFrom([x, y]) { // At subTurn == 2, jailers aren't effective (Jeff K) - if (this.subTurn == 1 && !!this.isImmobilized([x, y])) return []; - if (this.subTurn == 2) { - // Temporarily change pushed piece color. - // (Not using getPiece() because of lancers) - var oppCol = this.getColor(x, y); - var color = V.GetOppCol(oppCol); - var saveXYstate = this.board[x][y]; - this.board[x][y] = color + this.board[x][y].charAt(1); + const piece = this.getPiece(x, y); + const L = this.sentryPush.length; + if (this.subTurn == 1) { + const jsq = this.isImmobilized([x, y]); + if (!!jsq) { + let moves = []; + // Special pass move if king: + if (piece == V.KING) { + moves.push( + new Move({ + appear: [], + vanish: [], + start: { x: x, y: y }, + end: { x: jsq[0], y: jsq[1] } + }) + ); + } + else if (piece == V.LANCER && !!this.sentryPush[L-1]) { + // A pushed lancer next to the jailer: reorient + const color = this.getColor(x, y); + const curDir = this.board[x][y].charAt(1); + Object.keys(V.LANCER_DIRS).forEach(k => { + moves.push( + new Move({ + appear: [{ x: x, y: y, c: color, p: k }], + vanish: [{ x: x, y: y, c: color, p: curDir }], + start: { x: x, y: y }, + end: { x: jsq[0], y: jsq[1] } + }) + ); + }); + } + return moves; + } } let moves = []; - switch (this.getPiece(x, y)) { + switch (piece) { case V.JAILER: moves = this.getPotentialJailerMoves([x, y]); break; @@ -293,26 +343,26 @@ export const VariantRules = class EightpiecesRules extends ChessRules { moves = super.getPotentialMovesFrom([x, y]); break; } - const L = this.sentryPush.length; if (!!this.sentryPush[L-1]) { - // Delete moves walking back on sentry push path + // Delete moves walking back on sentry push path, + // only if not a pawn, and the piece is the pushed one. + const pl = this.sentryPush[L-1].length; + const finalPushedSq = this.sentryPush[L-1][pl-1]; moves = moves.filter(m => { if ( m.vanish[0].p != V.PAWN && + m.start.x == finalPushedSq.x && m.start.y == finalPushedSq.y && this.sentryPush[L-1].some(sq => sq.x == m.end.x && sq.y == m.end.y) ) { return false; } return true; }); - } - else if (this.subTurn == 2) { - // Don't forget to re-add the sentry on the board: - // Also fix color of pushed piece afterward: + } else if (this.subTurn == 2) { + // Put back the sentinel on board: + const color = this.turn; moves.forEach(m => { m.appear.push({x: x, y: y, p: V.SENTRY, c: color}); - m.appear[0].c = oppCol; - m.vanish[0].c = oppCol; }); } return moves; @@ -322,15 +372,19 @@ export const VariantRules = class EightpiecesRules extends ChessRules { const color = this.getColor(x, y); let moves = []; const [sizeX, sizeY] = [V.size.x, V.size.y]; - const shiftX = color == "w" ? -1 : 1; + let shiftX = (color == "w" ? -1 : 1); + if (this.subTurn == 2) shiftX *= -1; + const firstRank = color == "w" ? sizeX - 1 : 0; const startRank = color == "w" ? sizeX - 2 : 1; const lastRank = color == "w" ? 0 : sizeX - 1; + // Pawns might be pushed on 1st rank and attempt to move again: + if (!V.OnBoard(x + shiftX, y)) return []; + const finalPieces = - // No promotions after pushes! - x + shiftX == lastRank && this.subTurn == 1 - ? - Object.keys(V.LANCER_DIRS).concat( + // A push cannot put a pawn on last rank (it goes backward) + x + shiftX == lastRank + ? Object.keys(V.LANCER_DIRS).concat( [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN, V.SENTRY, V.JAILER]) : [V.PAWN]; if (this.board[x + shiftX][y] == V.EMPTY) { @@ -344,7 +398,9 @@ export const VariantRules = class EightpiecesRules extends ChessRules { ); } if ( - x == startRank && + // 2-squares jumps forbidden if pawn push + this.subTurn == 1 && + [startRank, firstRank].includes(x) && this.board[x + 2 * shiftX][y] == V.EMPTY ) { // Two squares jump @@ -370,10 +426,11 @@ export const VariantRules = class EightpiecesRules extends ChessRules { } } - // En passant: + // En passant: only on subTurn == 1 const Lep = this.epSquares.length; - const epSquare = this.epSquares[Lep - 1]; //always at least one element + const epSquare = this.epSquares[Lep - 1]; if ( + this.subTurn == 1 && !!epSquare && epSquare.x == x + shiftX && Math.abs(epSquare.y - y) == 1 @@ -391,12 +448,16 @@ export const VariantRules = class EightpiecesRules extends ChessRules { return moves; } - // Obtain all lancer moves in "step" direction, - // without final re-orientation. + // Obtain all lancer moves in "step" direction getPotentialLancerMoves_aux([x, y], step, tr) { let moves = []; // Add all moves to vacant squares until opponent is met: - const oppCol = V.GetOppCol(this.getColor(x, y)); + const color = this.getColor(x, y); + const oppCol = + this.subTurn == 1 + ? V.GetOppCol(color) + // at subTurn == 2, consider own pieces as opponent + : color; let sq = [x + step[0], y + step[1]]; while (V.OnBoard(sq[0], sq[1]) && this.getColor(sq[0], sq[1]) != oppCol) { if (this.board[sq[0]][sq[1]] == V.EMPTY) @@ -415,6 +476,7 @@ export const VariantRules = class EightpiecesRules extends ChessRules { // Add all lancer possible orientations, similar to pawn promotions. // Except if just after a push: allow all movements from init square then const L = this.sentryPush.length; + const color = this.getColor(x, y); if (!!this.sentryPush[L-1]) { // Maybe I was pushed const pl = this.sentryPush[L-1].length; @@ -423,16 +485,34 @@ export const VariantRules = class EightpiecesRules extends ChessRules { this.sentryPush[L-1][pl-1].y == y ) { // I was pushed: allow all directions (for this move only), but - // do not change direction after moving. - const color = this.getColor(x, y); + // do not change direction after moving, *except* if I keep the + // same orientation in which I was pushed. + const curDir = V.LANCER_DIRS[this.board[x][y].charAt(1)]; Object.values(V.LANCER_DIRS).forEach(step => { const dirCode = Object.keys(V.LANCER_DIRS).find(k => { - return (V.LANCER_DIRS[k][0] == step[0] && V.LANCER_DIRS[k][1] == step[1]); + return ( + V.LANCER_DIRS[k][0] == step[0] && + V.LANCER_DIRS[k][1] == step[1] + ); }); - Array.prototype.push.apply( - moves, - this.getPotentialLancerMoves_aux([x, y], step, { p: dirCode, c: color }) - ); + const dirMoves = + this.getPotentialLancerMoves_aux( + [x, y], + step, + { p: dirCode, c: color } + ); + if (curDir[0] == step[0] && curDir[1] == step[1]) { + // Keeping same orientation: can choose after + let chooseMoves = []; + dirMoves.forEach(m => { + Object.keys(V.LANCER_DIRS).forEach(k => { + let mk = JSON.parse(JSON.stringify(m)); + mk.appear[0].p = k; + moves.push(mk); + }); + }); + Array.prototype.push.apply(moves, chooseMoves); + } else Array.prototype.push.apply(moves, dirMoves); }); return moves; } @@ -451,7 +531,29 @@ export const VariantRules = class EightpiecesRules extends ChessRules { }); }); return moves; - } else return monodirMoves; + } else { + // I'm pushed: add potential nudges + let potentialNudges = []; + for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) { + if ( + V.OnBoard(x + step[0], y + step[1]) && + this.board[x + step[0]][y + step[1]] == V.EMPTY + ) { + const newDirCode = Object.keys(V.LANCER_DIRS).find(k => { + const codeStep = V.LANCER_DIRS[k]; + return (codeStep[0] == step[0] && codeStep[1] == step[1]); + }); + potentialNudges.push( + this.getBasicMove( + [x, y], + [x + step[0], y + step[1]], + { c: color, p: newDirCode } + ) + ); + } + } + return monodirMoves.concat(potentialNudges); + } } getPotentialSentryMoves([x, y]) { @@ -468,15 +570,13 @@ export const VariantRules = class EightpiecesRules extends ChessRules { m.vanish.pop(); } }); - // Can the pushed unit make any move? ...resulting in a non-self-check? const color = this.getColor(x, y); const fMoves = moves.filter(m => { - // Sentry push? + // Can the pushed unit make any move? ...resulting in a non-self-check? if (m.appear.length == 0) { let res = false; this.play(m); - let moves2 = this.filterValid( - this.getPotentialMovesFrom([m.end.x, m.end.y])); + let moves2 = this.getPotentialMovesFrom([m.end.x, m.end.y]); for (let m2 of moves2) { this.play(m2); res = !this.underCheck(color); @@ -498,125 +598,56 @@ export const VariantRules = class EightpiecesRules extends ChessRules { }); } - getPotentialKingMoves([x, y]) { - let moves = super.getPotentialKingMoves([x, y]); - // Augment with pass move is the king is immobilized: - const jsq = this.isImmobilized([x, y]); - if (!!jsq) { - moves.push( - new Move({ - appear: [], - vanish: [], - start: { x: x, y: y }, - end: { x: jsq[0], y: jsq[1] } - }) - ); - } - return moves; + getPotentialKingMoves(sq) { + const moves = this.getSlideNJumpMoves( + sq, + V.steps[V.ROOK].concat(V.steps[V.BISHOP]), + "oneStep" + ); + return ( + this.subTurn == 1 + ? moves.concat(this.getCastleMoves(sq)) + : moves + ); } - // Adapted: castle with jailer possible - getCastleMoves([x, y]) { - const c = this.getColor(x, y); - const firstRank = (c == "w" ? V.size.x - 1 : 0); - if (x != firstRank || y != this.INIT_COL_KING[c]) - return []; - - const oppCol = V.GetOppCol(c); - let moves = []; - let i = 0; - // King, then rook or jailer: - const finalSquares = [ - [2, 3], - [V.size.y - 2, V.size.y - 3] - ]; - castlingCheck: for ( - let castleSide = 0; - castleSide < 2; - castleSide++ - ) { - if (!this.castleFlags[c][castleSide]) continue; - // Rook (or jailer) and king are on initial position - - const finDist = finalSquares[castleSide][0] - y; - let step = finDist / Math.max(1, Math.abs(finDist)); - i = y; - do { - if ( - this.isAttacked([x, i], [oppCol]) || - (this.board[x][i] != V.EMPTY && - (this.getColor(x, i) != c || - ![V.KING, V.ROOK].includes(this.getPiece(x, i)))) - ) { - continue castlingCheck; - } - i += step; - } while (i != finalSquares[castleSide][0]); - - step = castleSide == 0 ? -1 : 1; - const rookOrJailerPos = - castleSide == 0 - ? Math.min(this.INIT_COL_ROOK[c], this.INIT_COL_JAILER[c]) - : Math.max(this.INIT_COL_ROOK[c], this.INIT_COL_JAILER[c]); - for (i = y + step; i != rookOrJailerPos; i += step) - if (this.board[x][i] != V.EMPTY) continue castlingCheck; - - // Nothing on final squares, except maybe king and castling rook or jailer? - for (i = 0; i < 2; i++) { - if ( - this.board[x][finalSquares[castleSide][i]] != V.EMPTY && - this.getPiece(x, finalSquares[castleSide][i]) != V.KING && - finalSquares[castleSide][i] != rookOrJailerPos - ) { - continue castlingCheck; - } - } - - // If this code is reached, castle is valid - const castlingPiece = this.getPiece(firstRank, rookOrJailerPos); - moves.push( - new Move({ - appear: [ - new PiPo({ x: x, y: finalSquares[castleSide][0], p: V.KING, c: c }), - new PiPo({ x: x, y: finalSquares[castleSide][1], p: castlingPiece, c: c }) - ], - vanish: [ - new PiPo({ x: x, y: y, p: V.KING, c: c }), - new PiPo({ x: x, y: rookOrJailerPos, p: castlingPiece, c: c }) - ], - end: - Math.abs(y - rookOrJailerPos) <= 2 - ? { x: x, y: rookOrJailerPos } - : { x: x, y: y + 2 * (castleSide == 0 ? -1 : 1) } - }) - ); - } - - return moves; + atLeastOneMove() { + // If in second-half of a move, we already know that a move is possible + if (this.subTurn == 2) return true; + return super.atLeastOneMove(); } filterValid(moves) { + if (moves.length == 0) return []; + const basicFilter = (m, c) => { + this.play(m); + const res = !this.underCheck(c); + this.undo(m); + return res; + }; // Disable check tests for sentry pushes, // because in this case the move isn't finished let movesWithoutSentryPushes = []; let movesWithSentryPushes = []; moves.forEach(m => { - if (m.appear.length > 0) movesWithoutSentryPushes.push(m); + // Second condition below for special king "pass" moves + if (m.appear.length > 0 || m.vanish.length == 0) + movesWithoutSentryPushes.push(m); else movesWithSentryPushes.push(m); }); - const filteredMoves = super.filterValid(movesWithoutSentryPushes); - // If at least one full move made, everything is allowed: - if (this.movesCount >= 2) - return filteredMoves.concat(movesWithSentryPushes); - // Else, forbid checks and captures: - const oppCol = V.GetOppCol(this.turn); - return filteredMoves.filter(m => { - if (m.vanish.length == 2 && m.appear.length == 1) return false; - this.play(m); - const res = !this.underCheck(oppCol); - this.undo(m); - return res; - }).concat(movesWithSentryPushes); + const color = this.turn; + const oppCol = V.GetOppCol(color); + const filteredMoves = + movesWithoutSentryPushes.filter(m => basicFilter(m, color)); + // If at least one full move made, everything is allowed. + // Else: forbid checks and captures. + return ( + this.movesCount >= 2 + ? filteredMoves + : filteredMoves.filter(m => { + return (m.vanish.length <= 1 && basicFilter(m, oppCol)); + }) + ).concat(movesWithSentryPushes); } getAllValidMoves() { @@ -626,130 +657,54 @@ export const VariantRules = class EightpiecesRules extends ChessRules { return this.filterValid(this.getPotentialMovesFrom(sentrySq)); } - updateVariables(move) { - const c = this.turn; - const piece = move.vanish[0].p; - const firstRank = (c == "w" ? V.size.x - 1 : 0); - - // Update king position + flags - if (piece == V.KING) { - this.kingPos[c][0] = move.appear[0].x; - this.kingPos[c][1] = move.appear[0].y; - this.castleFlags[c] = [false, false]; - return; - } + isAttacked(sq, color) { + return ( + super.isAttacked(sq, color) || + this.isAttackedByLancer(sq, color) || + this.isAttackedBySentry(sq, color) + // The jailer doesn't capture. + ); + } - // Update castling flags if rook or jailer moved (or is captured) - const oppCol = V.GetOppCol(c); - const oppFirstRank = V.size.x - 1 - firstRank; - let flagIdx = 0; - if ( - // Our rook moves? - move.start.x == firstRank && - this.INIT_COL_ROOK[c] == move.start.y - ) { - if (this.INIT_COL_ROOK[c] > this.INIT_COL_JAILER[c]) flagIdx++; - this.castleFlags[c][flagIdx] = false; - } else if ( - // Our jailer moves? - move.start.x == firstRank && - this.INIT_COL_JAILER[c] == move.start.y - ) { - if (this.INIT_COL_JAILER[c] > this.INIT_COL_ROOK[c]) flagIdx++; - this.castleFlags[c][flagIdx] = false; - } else if ( - // We took opponent's rook? - move.end.x == oppFirstRank && - this.INIT_COL_ROOK[oppCol] == move.end.y - ) { - if (this.INIT_COL_ROOK[oppCol] > this.INIT_COL_JAILER[oppCol]) flagIdx++; - this.castleFlags[oppCol][flagIdx] = false; - } else if ( - // We took opponent's jailer? - move.end.x == oppFirstRank && - this.INIT_COL_JAILER[oppCol] == move.end.y - ) { - if (this.INIT_COL_JAILER[oppCol] > this.INIT_COL_ROOK[oppCol]) flagIdx++; - this.castleFlags[oppCol][flagIdx] = false; + isAttackedBySlideNJump([x, y], color, piece, steps, oneStep) { + for (let step of steps) { + let rx = x + step[0], + ry = y + step[1]; + while (V.OnBoard(rx, ry) && this.board[rx][ry] == V.EMPTY && !oneStep) { + rx += step[0]; + ry += step[1]; + } + if ( + V.OnBoard(rx, ry) && + this.getPiece(rx, ry) == piece && + this.getColor(rx, ry) == color && + !this.isImmobilized([rx, ry]) + ) { + return true; + } } + return false; + } - if (move.appear.length == 0 && move.vanish.length == 1) { - // The sentry is about to push a piece: subTurn goes from 1 to 2 - this.sentryPos = { x: move.end.x, y: move.end.y }; - } else if (this.subTurn == 2) { - // A piece is pushed: forbid array of squares between start and end - // of move, included (except if it's a pawn) - let squares = []; - if (move.vanish[0].p != V.PAWN) { - if ([V.KNIGHT,V.KING].includes(move.vanish[0].p)) - // short-range pieces: just forbid initial square - squares.push(move.start); - else { - const deltaX = move.end.x - move.start.x; - const deltaY = move.end.y - move.start.y; - const step = [ - deltaX / Math.abs(deltaX) || 0, - deltaY / Math.abs(deltaY) || 0 - ]; - for ( - let sq = {x: move.start.x, y: move.start.y}; - sq.x != move.end.x && sq.y != move.end.y; - sq.x += step[0], sq.y += step[1] - ) { - squares.push(sq); - } + isAttackedByPawn([x, y], color) { + const pawnShift = (color == "w" ? 1 : -1); + if (x + pawnShift >= 0 && x + pawnShift < V.size.x) { + for (let i of [-1, 1]) { + if ( + y + i >= 0 && + y + i < V.size.y && + this.getPiece(x + pawnShift, y + i) == V.PAWN && + this.getColor(x + pawnShift, y + i) == color && + !this.isImmobilized([x + pawnShift, y + i]) + ) { + return true; } - // Add end square as well, to know if I was pushed (useful for lancers) - squares.push(move.end); } - this.sentryPush.push(squares); - } else this.sentryPush.push(null); - } - - // TODO: cleaner (global) update/unupdate variables logic, rename... - unupdateVariables(move) { - super.unupdateVariables(move); - this.sentryPush.pop(); - } - - play(move) { - move.flags = JSON.stringify(this.aggregateFlags()); - this.epSquares.push(this.getEpSquare(move)); - V.PlayOnBoard(this.board, move); - this.updateVariables(move); - // Is it a sentry push? (useful for undo) - move.sentryPush = (this.subTurn == 2); - if (this.subTurn == 1) this.movesCount++; - if (move.appear.length == 0 && move.vanish.length == 1) this.subTurn = 2; - else { - // Turn changes only if not a sentry "pre-push" - this.turn = V.GetOppCol(this.turn); - this.subTurn = 1; } + return false; } - undo(move) { - this.epSquares.pop(); - this.disaggregateFlags(JSON.parse(move.flags)); - V.UndoOnBoard(this.board, move); - const L = this.sentryPush.length; - // Decrement movesCount except if the move is a sentry push - if (!move.sentryPush) this.movesCount--; - // Turn changes only if not undoing second part of a sentry push - if (!move.sentryPush || this.subTurn == 1) - this.turn = V.GetOppCol(this.turn); - this.unupdateVariables(move); - } - - isAttacked(sq, colors) { - return ( - super.isAttacked(sq, colors) || - this.isAttackedByLancer(sq, colors) || - this.isAttackedBySentry(sq, colors) - ); - } - - isAttackedByLancer([x, y], colors) { + isAttackedByLancer([x, y], color) { for (let step of V.steps[V.ROOK].concat(V.steps[V.BISHOP])) { // If in this direction there are only enemy pieces and empty squares, // and we meet a lancer: can he reach us? @@ -760,10 +715,17 @@ export const VariantRules = class EightpiecesRules extends ChessRules { V.OnBoard(coord.x, coord.y) && ( this.board[coord.x][coord.y] == V.EMPTY || - colors.includes(this.getColor(coord.x, coord.y)) + this.getColor(coord.x, coord.y) == color ) ) { - lancerPos.push(coord); + if ( + this.getPiece(coord.x, coord.y) == V.LANCER && + !this.isImmobilized([coord.x, coord.y]) + ) { + lancerPos.push({x: coord.x, y: coord.y}); + } + coord.x += step[0]; + coord.y += step[1]; } for (let xy of lancerPos) { const dir = V.LANCER_DIRS[this.board[xy.x][xy.y].charAt(1)]; @@ -776,20 +738,31 @@ export const VariantRules = class EightpiecesRules extends ChessRules { // Helper to check sentries attacks: selfAttack([x1, y1], [x2, y2]) { const color = this.getColor(x1, y1); + const oppCol = V.GetOppCol(color); const sliderAttack = (allowedSteps, lancer) => { - const deltaX = x2 - x1; - const deltaY = y2 - y1; - const step = [ deltaX / Math.abs(deltaX), deltaY / Math.abs(deltaY) ]; - if (allowedStep.every(st => st[0] != step[0] || st[1] != step[1])) + const deltaX = x2 - x1, + absDeltaX = Math.abs(deltaX); + const deltaY = y2 - y1, + absDeltaY = Math.abs(deltaY); + const step = [ deltaX / absDeltaX || 0, deltaY / absDeltaY || 0 ]; + if ( + // Check that the step is a priori valid: + (absDeltaX != absDeltaY && deltaX != 0 && deltaY != 0) || + allowedSteps.every(st => st[0] != step[0] || st[1] != step[1]) + ) { return false; - let sq = [ x1 = step[0], y1 + step[1] ]; - while (sq[0] != x2 && sq[1] != y2) { + } + let sq = [ x1 + step[0], y1 + step[1] ]; + while (sq[0] != x2 || sq[1] != y2) { if ( + // NOTE: no need to check OnBoard in this special case (!lancer && this.board[sq[0]][sq[1]] != V.EMPTY) || - (!!lancer && this.getColor(sq[0], sq[1]) != color) + (!!lancer && this.getColor(sq[0], sq[1]) == oppCol) ) { return false; } + sq[0] += step[0]; + sq[1] += step[1]; } return true; }; @@ -825,17 +798,18 @@ export const VariantRules = class EightpiecesRules extends ChessRules { return false; } - isAttackedBySentry([x, y], colors) { + isAttackedBySentry([x, y], color) { // Attacked by sentry means it can self-take our king. // Just check diagonals of enemy sentry(ies), and if it reaches // one of our pieces: can I self-take? - const color = V.GetOppCol(colors[0]); + const myColor = V.GetOppCol(color); let candidates = []; for (let i=0; i { + const setEval = (move, next) => { const score = this.getCurrentScore(); + const curEval = move.eval; if (score != "*") { move.eval = score == "1/2" ? 0 : (score == "1-0" ? 1 : -1) * maxeval; - } else move[i].eval = this.evalPosition(); + } else move.eval = this.evalPosition(); + if ( + // "next" is defined after sentry pushes + !!next && ( + !curEval || + color == 'w' && move.eval > curEval || + color == 'b' && move.eval < curEval + ) + ) { + move.second = next; + } }; // Just search_depth == 1 (because of sentries. TODO: can do better...) @@ -898,7 +983,7 @@ export const VariantRules = class EightpiecesRules extends ChessRules { const moves2 = this.getAllValidMoves(); moves2.forEach(m2 => { this.play(m2); - setEval(m1); + setEval(m1, m2); this.undo(m2); }); } @@ -911,12 +996,48 @@ export const VariantRules = class EightpiecesRules extends ChessRules { let candidates = [0]; for (let j = 1; j < moves1.length && moves1[j].eval == moves1[0].eval; j++) candidates.push(j); - return moves1[candidates[randInt(candidates.length)]]; + const choice = moves1[candidates[randInt(candidates.length)]]; + return (!choice.second ? choice : [choice, choice.second]); + } + + // For moves notation: + static get LANCER_DIRNAMES() { + return { + 'c': "N", + 'd': "NE", + 'e': "E", + 'f': "SE", + 'g': "S", + 'h': "SW", + 'm': "W", + 'o': "NW" + }; } getNotation(move) { // Special case "king takes jailer" is a pass move if (move.appear.length == 0 && move.vanish.length == 0) return "pass"; - return super.getNotation(move); + let notation = undefined; + if (this.subTurn == 2) { + // Do not consider appear[1] (sentry) for sentry pushes + const simpleMove = { + appear: [move.appear[0]], + vanish: move.vanish, + start: move.start, + end: move.end + }; + notation = super.getNotation(simpleMove); + } else notation = super.getNotation(move); + if (Object.keys(V.LANCER_DIRNAMES).includes(move.vanish[0].p)) + // Lancer: add direction info + notation += "=" + V.LANCER_DIRNAMES[move.appear[0].p]; + else if ( + move.vanish[0].p == V.PAWN && + Object.keys(V.LANCER_DIRNAMES).includes(move.appear[0].p) + ) { + // Fix promotions in lancer: + notation = notation.slice(0, -1) + "L:" + V.LANCER_DIRNAMES[move.appear[0].p]; + } + return notation; } };