From: Benjamin Auder Date: Wed, 29 Apr 2020 19:55:45 +0000 (+0200) Subject: Simplify Monster + Doublemove2. Smoother example games X-Git-Url: https://git.auder.net/variants/Chakart/pieces/%7B%7B%20path%28%27mixstore_static_about%27%29%20%7D%7D?a=commitdiff_plain;h=bc0b9205e41c5db0552e4ccf060b945342e36ed0;p=vchess.git Simplify Monster + Doublemove2. Smoother example games --- diff --git a/client/src/components/ComputerGame.vue b/client/src/components/ComputerGame.vue index ad56543e..f611167d 100644 --- a/client/src/components/ComputerGame.vue +++ b/client/src/components/ComputerGame.vue @@ -44,7 +44,11 @@ export default { setTimeout(() => { if (this.currentUrl != document.location.href) return; //page change self.$refs["basegame"].play(compMove, "received"); - self.processMove(compMove); + const animationLength = + // 250 = length of animation, 500 = delay between sub-moves + // TODO: a callback would be cleaner. + 250 + (Array.isArray(compMove) ? (compMove.length - 1) * 750 : 0); + setTimeout(() => self.processMove(compMove), animationLength); self.compThink = false; if (self.game.score != "*") // User action diff --git a/client/src/translations/rules/Doublemove2/en.pug b/client/src/translations/rules/Doublemove2/en.pug index c1bda2ee..ca24491f 100644 --- a/client/src/translations/rules/Doublemove2/en.pug +++ b/client/src/translations/rules/Doublemove2/en.pug @@ -1,5 +1,5 @@ p.boxed - | Move twice at every turn. + | Move twice at every turn. The goal is to capture the king. p. The only difference with orthodox chess is the double-move rule, @@ -8,7 +8,7 @@ p. p. At the very first move of the game, white make only one move - as usual. However, after that and for all the game each side must play twice at - every turn. The goal is to checkmate. + every turn (even if the first move captures the enemy king). figure.diagram-container .diagram.diag12 @@ -17,14 +17,12 @@ figure.diagram-container | fen:r1bqkbnr/pppp1ppp/2n5/4p3/2B1P3/5Q2/PPPP1PPP/RNB1K1NR: figcaption. Left: after the moves 1.e4 e5, the 'd' pawn is pinned. - Right: the black king is under check. + Right: the black king is "under check". p. In the diagram position on the left, after the first black move ...e5, - the 'd' pawn is pinned because moving it would allow 2.Bb5,Bxe8 capturing - the king. - On the right, after 2.Qf3,Bc4 black king is under check because of - the options 3.Bxf7,Bxe8 or 3.Qxf7,Qxe8. + moving the 'd' pawn would allow 2.Bb5,Bxe8 capturing the king. + On the right, after 2.Qf3,Bc4 the threats are 3.Bxf7,Bxe8 and 3.Qxf7,Qxe8. h3 En-passant capture @@ -50,3 +48,5 @@ p | . It is also playable a(href="https://greenchess.net/rules.php?v=double-move") on greenchess | . + +p Inventor: Fred Galvin (1957) diff --git a/client/src/translations/rules/Doublemove2/es.pug b/client/src/translations/rules/Doublemove2/es.pug index aa4751d6..179025b3 100644 --- a/client/src/translations/rules/Doublemove2/es.pug +++ b/client/src/translations/rules/Doublemove2/es.pug @@ -1,15 +1,15 @@ p.boxed - | Juega dos jugadas a cada turno. + | Juega dos jugadas a cada turno. El objetivo es capturar al rey. p. La única diferencia con el juego ortodoxo es la regla del doble movimiento, pero eso afecta mucho el juego p. - Al comienzo del juego, los blancos solo juegan un movimiento, como + Al comienzo del juego, las blancas solo juegan un movimiento, como en general. Sin embargo, después de eso y por el resto del juego, - cada lado debe jugar dos jugadas cada turno. - El objetivo es de dar jaque mate. + cada lado debe jugar dos jugadas cada turno + (incluso si la primera captura al rey contrario). figure.diagram-container .diagram.diag12 @@ -18,14 +18,13 @@ figure.diagram-container | fen:r1bqkbnr/pppp1ppp/2n5/4p3/2B1P3/5Q2/PPPP1PPP/RNB1K1NR: figcaption. Izquierda: después de las jugadas 1.e4 e5, el peón 'd' se clava. - Derecha: el rey negro está en jaque. + Derecha: el rey negro está "en jaque". p. En la posición del diagrama de la izquierda, después del primer movimiento - negro ...e5, el peón 'd' está clavado porque su movimiento autorizaría - 2.Bb5,Bxe8 captura el rey. - A la derecha, después de 2.Qf3,Bc4 el rey negro está en jaque debido a las - posibilidades 3.Bxf7,Bxe8 o 3.Qxf7,Qxe8. + negro ...e5, un movimiento del peón 'd' autorizaría 2.Bb5,Bxe8 que + captura el rey. A la derecha, después de 2.Qf3,Bc4 las amenazas son + 3.Bxf7,Bxe8 y 3.Qxf7,Qxe8. h3 Captura en passant @@ -52,3 +51,5 @@ p | . También es jugable a(href="https://greenchess.net/rules.php?v=double-move") en greenchess | . + +p Inventor: Fred Galvin (1957) diff --git a/client/src/translations/rules/Doublemove2/fr.pug b/client/src/translations/rules/Doublemove2/fr.pug index 66021864..0dff04f9 100644 --- a/client/src/translations/rules/Doublemove2/fr.pug +++ b/client/src/translations/rules/Doublemove2/fr.pug @@ -1,5 +1,5 @@ p.boxed - | Jouez deux coups à chaque tour. + | Jouez deux coups à chaque tour. Le but est de capturer le roi. p. La seule différence avec le jeu orthodoxe est la règle du double-coup, mais @@ -8,7 +8,8 @@ p. p. Au tout début de la partie les blancs ne jouent qu'un seul coup, comme d'habitude. Cependant, après cela et ce pour tout le reste de la partie - chaque camp doit jouer deux coups à chaque tour. L'objectif est de mater. + chaque camp doit jouer deux coups à chaque tour + (même si le premier capture le roi adverse). figure.diagram-container .diagram.diag12 @@ -17,14 +18,12 @@ figure.diagram-container | fen:r1bqkbnr/pppp1ppp/2n5/4p3/2B1P3/5Q2/PPPP1PPP/RNB1K1NR: figcaption. Gauche : après les coups 1.e4 e5, le pion 'd' est cloué. - Droite : le roi noir est en échec. + Droite : le roi noir est "en échec". p. Dans la position du diagramme à gauche, après le premier coup noir ...e5, - le pion 'd' est cloué car son déplacement autoriserait 2.Bb5,Bxe8 capturant - le roi. - À droite, après 2.Qf3,Bc4 le roi noir est en échec à cause des possibilités - 3.Bxf7,Bxe8 ou 3.Qxf7,Qxe8. + un déplacement du pion 'd' autoriserait 2.Bb5,Bxe8 capturant le roi. + À droite, après 2.Qf3,Bc4 les menaces sont 3.Bxf7,Bxe8 et 3.Qxf7,Qxe8. h3 Prise en passant @@ -50,3 +49,5 @@ p | . Elle est jouable également a(href="https://greenchess.net/rules.php?v=double-move") sur greenchess | . + +p Inventeur : Fred Galvin (1957) diff --git a/client/src/translations/rules/Monster/en.pug b/client/src/translations/rules/Monster/en.pug index 8e7061de..d0551d10 100644 --- a/client/src/translations/rules/Monster/en.pug +++ b/client/src/translations/rules/Monster/en.pug @@ -8,10 +8,8 @@ figure.diagram-container p. The white army can appear much too small, but the power to move twice in a - row shouldn't be underestimated. At each turn white plays two moves with - only one constraint: do not be under check in the end. - So if the white king attacks a defended piece, he can take it anyway by - coming back on its initial square on (sub)move 2. + row shouldn't be underestimated. At each turn white plays two moves + without any constraint. The goal is to capture the king. figure.diagram-container .diagram.diag12 diff --git a/client/src/translations/rules/Monster/es.pug b/client/src/translations/rules/Monster/es.pug index edf1bdf2..f9149f6e 100644 --- a/client/src/translations/rules/Monster/es.pug +++ b/client/src/translations/rules/Monster/es.pug @@ -10,10 +10,7 @@ figure.diagram-container p. El ejército blanco puede parecer demasiado pequeño, pero el poder de jugar dos veces seguidas y no debe subestimarse. En cada turno las blancas juegan - dos jugadas con la única restricción de no estar en jaque hasta el final. - Entonces, si tu rey blanco ataca una habitación protegida, él puede - tómalo de todos modos y luego regresa a tu caso inicial en el segundo - (sub)movimiento. + dos jugadas sin ninguna restricción. El objetivo es capturar al rey. figure.diagram-container .diagram.diag12 diff --git a/client/src/translations/rules/Monster/fr.pug b/client/src/translations/rules/Monster/fr.pug index 757ae3e6..c0b99100 100644 --- a/client/src/translations/rules/Monster/fr.pug +++ b/client/src/translations/rules/Monster/fr.pug @@ -10,9 +10,8 @@ figure.diagram-container p. L'armée blanche peut paraître bien trop réduite, mais le pouvoir de jouer deux fois d'affilée ne doit pas être sous-estimé. À chaque tour les - blancs jouent deux coups avec pour seule contrainte de ne pas être en échec - à la fin. Ainsi, si le roi blanc attaque une pièce protégée, il peut la - prendre quand-même puis revenir sur sa case initiale au second (sous)coup. + blancs jouent deux coups sans aucune contrainte. + L'objectif est de capturer le roi. figure.diagram-container .diagram.diag12 diff --git a/client/src/variants/Doublemove1.js b/client/src/variants/Doublemove1.js index 7d1ee4dc..c30ad0cf 100644 --- a/client/src/variants/Doublemove1.js +++ b/client/src/variants/Doublemove1.js @@ -201,7 +201,7 @@ export class Doublemove1Rules extends ChessRules { return res; }; - let moves11 = this.getAllValidMoves(); + const moves11 = this.getAllValidMoves(); let doubleMoves = []; // Rank moves using a min-max at depth 2 for (let i = 0; i < moves11.length; i++) { @@ -209,13 +209,14 @@ export class Doublemove1Rules extends ChessRules { if (this.turn != color) { // We gave check with last move: search the best opponent move doubleMoves.push({ moves: [moves11[i]], eval: getBestMoveEval() }); - } else { + } + else { let moves12 = this.getAllValidMoves(); for (let j = 0; j < moves12.length; j++) { this.play(moves12[j]); doubleMoves.push({ moves: [moves11[i], moves12[j]], - eval: getBestMoveEval() + eval: getBestMoveEval() + 0.05 - Math.random() / 10 }); this.undo(moves12[j]); } @@ -223,6 +224,8 @@ export class Doublemove1Rules extends ChessRules { this.undo(moves11[i]); } + // TODO: array + sort + candidates logic not required when adding small + // fluctuations to the eval function (could also be generalized). doubleMoves.sort((a, b) => { return (color == "w" ? 1 : -1) * (b.eval - a.eval); }); @@ -234,7 +237,6 @@ export class Doublemove1Rules extends ChessRules { ) { candidates.push(i); } - const selected = doubleMoves[randInt(candidates.length)].moves; if (selected.length == 1) return selected[0]; return selected; diff --git a/client/src/variants/Doublemove2.js b/client/src/variants/Doublemove2.js index d1afff83..080d13b6 100644 --- a/client/src/variants/Doublemove2.js +++ b/client/src/variants/Doublemove2.js @@ -79,40 +79,23 @@ export class Doublemove2Rules extends ChessRules { return moves; } - isAttacked(sq, color, castling) { - const singleMoveAttack = super.isAttacked(sq, color); - if (singleMoveAttack) return true; - if (!!castling) { - if (this.subTurn == 1) - // Castling at move 1 could be done into check - return false; - return singleMoveAttack; - } - // Double-move allowed: - const curTurn = this.turn; - this.turn = color; - const moves1 = super.getAllPotentialMoves(); - this.turn = curTurn; - for (let move of moves1) { - this.play(move); - const res = super.isAttacked(sq, color); - this.undo(move); - if (res) return res; - } + isAttacked(sq, color) { + // Goal is king capture => no checks return false; } filterValid(moves) { - if (this.subTurn == 1) { - return moves.filter(m1 => { - this.play(m1); - // NOTE: no recursion because next call will see subTurn == 2 - const res = super.atLeastOneMove(); - this.undo(m1); - return res; - }); - } - return super.filterValid(moves); + return moves; + } + + getCheckSquares() { + return []; + } + + getCurrentScore() { + const color = this.turn; + if (this.kingPos[color][0] < 0) return (color == 'w' ? "0-1" : "1-0"); + return "*"; } play(move) { @@ -139,12 +122,14 @@ export class Doublemove2Rules extends ChessRules { const firstRank = c == "w" ? V.size.x - 1 : 0; if (piece == V.KING && move.appear.length > 0) { - this.kingPos[c][0] = move.appear[0].x; - this.kingPos[c][1] = move.appear[0].y; + this.kingPos[c] = [move.appear[0].x, move.appear[0].y]; this.castleFlags[c] = [V.size.y, V.size.y]; return; } const oppCol = V.GetOppCol(c); + if (move.vanish.length == 2 && move.vanish[1].p == V.KING) + // Opponent's king is captured, game over + this.kingPos[oppCol] = [-1, -1]; const oppFirstRank = V.size.x - 1 - firstRank; if ( move.start.x == firstRank && //our rook moves? @@ -152,7 +137,8 @@ export class Doublemove2Rules extends ChessRules { ) { const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1); this.castleFlags[c][flagIdx] = V.size.y; - } else if ( + } + else if ( move.end.x == oppFirstRank && //we took opponent rook? this.castleFlags[oppCol].includes(move.end.y) ) { @@ -175,28 +161,47 @@ export class Doublemove2Rules extends ChessRules { this.turn = V.GetOppCol(this.turn); } if (this.movesCount > 0) this.subTurn = 3 - this.subTurn; - super.postUndo(move); + this.postUndo(move); } - static get VALUES() { - return { - p: 1, - r: 5, - n: 3, - b: 3, - q: 7, //slightly less than in orthodox game - k: 1000 - }; + postUndo(move) { + if (move.vanish.length == 2 && move.vanish[1].p == V.KING) + // Opponent's king was captured + this.kingPos[move.vanish[1].c] = [move.vanish[1].x, move.vanish[1].y]; + super.postUndo(move); } - // No alpha-beta here, just adapted min-max at depth 1(+1) + // No alpha-beta here, just adapted min-max at depth 2(+1) getComputerMove() { + const maxeval = V.INFINITY; const color = this.turn; + const oppCol = V.GetOppCol(this.turn); + + // Search best (half) move for opponent turn + const getBestMoveEval = () => { + let score = this.getCurrentScore(); + if (score != "*") return maxeval * (score == "1-0" ? 1 : -1); + let moves = this.getAllValidMoves(); + let res = oppCol == "w" ? -maxeval : maxeval; + for (let m of moves) { + this.play(m); + score = this.getCurrentScore(); + if (score != "*") { + // King captured + this.undo(m); + return maxeval * (score == "1-0" ? 1 : -1); + } + const evalPos = this.evalPosition(); + res = oppCol == "w" ? Math.max(res, evalPos) : Math.min(res, evalPos); + this.undo(m); + } + return res; + }; + const moves11 = this.getAllValidMoves(); if (this.movesCount == 0) // First white move at random: return moves11[randInt(moves11.length)]; - let doubleMoves = []; // Rank moves using a min-max at depth 2 for (let i = 0; i < moves11.length; i++) { @@ -206,7 +211,8 @@ export class Doublemove2Rules extends ChessRules { this.play(moves12[j]); doubleMoves.push({ moves: [moves11[i], moves12[j]], - eval: this.evalPosition() + // Small fluctuations to uniformize play a little + eval: getBestMoveEval() + 0.05 - Math.random() / 10 }); this.undo(moves12[j]); } diff --git a/client/src/variants/Monster.js b/client/src/variants/Monster.js index 1fb6a773..071c8db0 100644 --- a/client/src/variants/Monster.js +++ b/client/src/variants/Monster.js @@ -46,23 +46,24 @@ export class MonsterRules extends ChessRules { } isAttacked(sq, color, castling) { - const singleMoveAttack = super.isAttacked(sq, color); - if (singleMoveAttack) return true; - if (color == 'b' || !!castling) return singleMoveAttack; - // Attacks by white: double-move allowed - const curTurn = this.turn; - this.turn = 'w'; - const w1Moves = super.getAllPotentialMoves(); - this.turn = curTurn; - for (let move of w1Moves) { - this.play(move); - const res = super.isAttacked(sq, 'w'); - this.undo(move); - if (res) return res; - } + // Goal is king capture => no checks return false; } + filterValid(moves) { + return moves; + } + + getCheckSquares() { + return []; + } + + getCurrentScore() { + const color = this.turn; + if (this.kingPos[color][0] < 0) return (color == 'w' ? "0-1" : "1-0"); + return "*"; + } + play(move) { move.flags = JSON.stringify(this.aggregateFlags()); if (this.turn == 'b' || this.subTurn == 2) @@ -105,10 +106,11 @@ export class MonsterRules extends ChessRules { // Definition of 'c' in base class doesn't work: const c = move.vanish[0].c; const piece = move.vanish[0].p; - if (piece == V.KING) { - this.kingPos[c][0] = move.appear[0].x; - this.kingPos[c][1] = move.appear[0].y; - } + if (piece == V.KING) + this.kingPos[c] = [move.appear[0].x, move.appear[0].y]; + if (move.vanish.length == 2 && move.vanish[1].p == V.KING) + // Opponent's king is captured, game over + this.kingPos[move.vanish[1].c] = [-1, -1]; this.updateCastleFlags(move, piece); } @@ -120,52 +122,49 @@ export class MonsterRules extends ChessRules { if (this.subTurn == 2) this.subTurn = 1; else this.turn = 'b'; this.movesCount--; - } else { + } + else { this.turn = 'w'; this.subTurn = 2; } this.postUndo(move); } - filterValid(moves) { - if (this.turn == 'w' && this.subTurn == 1) { - return moves.filter(m1 => { - this.play(m1); - // NOTE: no recursion because next call will see subTurn == 2 - const res = super.atLeastOneMove(); - this.undo(m1); - return res; - }); - } - return super.filterValid(moves); - } - - static get SEARCH_DEPTH() { - return 1; + postUndo(move) { + if (move.vanish.length == 2 && move.vanish[1].p == V.KING) + // Opponent's king was captured + this.kingPos[move.vanish[1].c] = [move.vanish[1].x, move.vanish[1].y]; + super.postUndo(move); } + // Custom search at depth 1(+1) getComputerMove() { - const color = this.turn; - if (color == 'w') { + const getBestWhiteMove = (terminal) => { // Generate all sequences of 2-moves - const moves1 = this.getAllValidMoves(); + let moves1 = this.getAllValidMoves(); moves1.forEach(m1 => { m1.eval = -V.INFINITY; m1.move2 = null; this.play(m1); - const moves2 = this.getAllValidMoves(); - moves2.forEach(m2 => { - this.play(m2); - const eval2 = this.evalPosition(); - this.undo(m2); - if (eval2 > m1.eval) { - m1.eval = eval2; - m1.move2 = m2; - } - }); + if (!!terminal) m1.eval = this.evalPosition(); + else { + const moves2 = this.getAllValidMoves(); + moves2.forEach(m2 => { + this.play(m2); + const eval2 = this.evalPosition() + 0.05 - Math.random() / 10; + this.undo(m2); + if (eval2 > m1.eval) { + m1.eval = eval2; + m1.move2 = m2; + } + }); + } this.undo(m1); }); moves1.sort((a, b) => b.eval - a.eval); + if (!!terminal) + // The move itself doesn't matter, only its eval: + return moves1[0]; let candidates = [0]; for ( let i = 1; @@ -178,8 +177,31 @@ export class MonsterRules extends ChessRules { const move2 = moves1[idx].move2; delete moves1[idx]["move2"]; return [moves1[idx], move2]; - } - // For black at depth 1, super method is fine: - return super.getComputerMove(); + }; + + const getBestBlackMove = () => { + let moves = this.getAllValidMoves(); + moves.forEach(m => { + m.eval = V.INFINITY; + this.play(m); + const evalM = getBestWhiteMove("terminal").eval + this.undo(m); + if (evalM < m.eval) m.eval = evalM; + }); + moves.sort((a, b) => a.eval - b.eval); + let candidates = [0]; + for ( + let i = 1; + i < moves.length && moves[i].eval == moves[0].eval; + i++ + ) { + candidates.push(i); + } + const idx = candidates[randInt(candidates.length)]; + return moves[idx]; + }; + + const color = this.turn; + return (color == 'w' ? getBestWhiteMove() : getBestBlackMove()); } }; diff --git a/client/src/variants/Teleport.js b/client/src/variants/Teleport.js index 7704184f..6cf14a80 100644 --- a/client/src/variants/Teleport.js +++ b/client/src/variants/Teleport.js @@ -311,8 +311,6 @@ export class TeleportRules extends ChessRules { (color == 'w' && mvEval > m.eval) || (color == 'b' && mvEval < m.eval) ) { - // TODO: if many second moves have the same eval, only the - // first is kept. Could be randomized. m.eval = mvEval; m.next = m2; }