From: Benjamin Auder Date: Tue, 31 Mar 2020 23:00:26 +0000 (+0200) Subject: Fix Omega castling and pieces randomization, fix a bug when undoing partial multi... X-Git-Url: https://git.auder.net/%7B%7B%20asset%28%27mixstore/css/static/doc/index.css?a=commitdiff_plain;h=e90bafa8fb5fb7641728231bf2398590d96c672a;p=vchess.git Fix Omega castling and pieces randomization, fix a bug when undoing partial multi-move. Draft Rococo and Maxima rules --- diff --git a/client/public/images/pieces/Maxima/bd.svg b/client/public/images/pieces/Maxima/bd.svg new file mode 100644 index 00000000..09954492 --- /dev/null +++ b/client/public/images/pieces/Maxima/bd.svg @@ -0,0 +1,105 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/client/public/images/pieces/Maxima/bg.svg b/client/public/images/pieces/Maxima/bg.svg new file mode 100644 index 00000000..6afc7b5e --- /dev/null +++ b/client/public/images/pieces/Maxima/bg.svg @@ -0,0 +1,79 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + diff --git a/client/public/images/pieces/Maxima/bm.svg b/client/public/images/pieces/Maxima/bm.svg new file mode 100644 index 00000000..fdc0ee59 --- /dev/null +++ b/client/public/images/pieces/Maxima/bm.svg @@ -0,0 +1,92 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + diff --git a/client/public/images/pieces/Maxima/nothing.svg b/client/public/images/pieces/Maxima/nothing.svg new file mode 100644 index 00000000..affd020e --- /dev/null +++ b/client/public/images/pieces/Maxima/nothing.svg @@ -0,0 +1,56 @@ + + + + + + image/svg+xml + + + + + + + + diff --git a/client/public/images/pieces/Maxima/wd.svg b/client/public/images/pieces/Maxima/wd.svg new file mode 100644 index 00000000..12f2b27a --- /dev/null +++ b/client/public/images/pieces/Maxima/wd.svg @@ -0,0 +1,94 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + diff --git a/client/public/images/pieces/Maxima/wg.svg b/client/public/images/pieces/Maxima/wg.svg new file mode 100644 index 00000000..5ab016a6 --- /dev/null +++ b/client/public/images/pieces/Maxima/wg.svg @@ -0,0 +1,145 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/client/public/images/pieces/Maxima/wm.svg b/client/public/images/pieces/Maxima/wm.svg new file mode 100644 index 00000000..bf9f16ad --- /dev/null +++ b/client/public/images/pieces/Maxima/wm.svg @@ -0,0 +1,97 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + diff --git a/client/public/images/pieces/Omega/bc.svg b/client/public/images/pieces/Omega/bc.svg index e3d2eb68..1040316f 100644 --- a/client/public/images/pieces/Omega/bc.svg +++ b/client/public/images/pieces/Omega/bc.svg @@ -7,26 +7,29 @@ xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" - height="100%" - width="100%" + width="177.17" + height="177.17" + shape-rendering="geometricPrecision" + image-rendering="optimizeQuality" + fill-rule="evenodd" + clip-rule="evenodd" + viewBox="0 0 50 50" version="1.1" - viewBox="0 0 2048 2048" - id="svg18" - sodipodi:docname="bc.svg" - inkscape:version="0.92.4 5da689c313, 2019-01-14"> + id="svg27599" + sodipodi:docname="bChampion.svg" + inkscape:version="0.92.4 (5da689c313, 2019-01-14)"> + id="metadata27603"> image/svg+xml + - - + showguides="false" + inkscape:zoom="2.664108" + inkscape:cx="105.33637" + inkscape:cy="39.05641" + inkscape:window-x="1912" + inkscape:window-y="-8" + inkscape:window-maximized="1" + inkscape:current-layer="svg27599" /> + + + + + + + + + + + + + + + + + + + + + + + + + + - - - + transform="matrix(1.2044555,0,0,1.2044555,-1.9681825,-0.2899927)" + id="g2329" + style="stroke-width:1.40585434;stroke-miterlimit:4;stroke-dasharray:none;fill:#1f1a17;fill-opacity:1"> + + + - - + style="fill:#1f1a17;stroke:#1f1a17;stroke-width:1.40585434;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;fill-opacity:1" + inkscape:connector-curvature="0" + d="m 22.447,4.833 c 0,3.024 4.98,5.545 7.47,7.057 2.49,1.512 3.485,3.276 3.485,5.545 0,2.269 0,14.114 0,16.383 0,2.269 4.981,4.285 4.981,4.285 H 22.447" + id="path2327" /> + + + + diff --git a/client/public/images/pieces/Omega/bw.svg b/client/public/images/pieces/Omega/bw.svg index 5c6b2bb8..70e9b793 100644 --- a/client/public/images/pieces/Omega/bw.svg +++ b/client/public/images/pieces/Omega/bw.svg @@ -7,26 +7,29 @@ xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" - height="100%" - width="100%" + width="177.17" + height="177.17" + shape-rendering="geometricPrecision" + image-rendering="optimizeQuality" + fill-rule="evenodd" + clip-rule="evenodd" + viewBox="0 0 50 50" version="1.1" - viewBox="0 0 2048 2048" - id="svg16" - sodipodi:docname="bw.svg" - inkscape:version="0.92.4 5da689c313, 2019-01-14"> + id="svg27599" + sodipodi:docname="bWizard.svg" + inkscape:version="0.92.4 (5da689c313, 2019-01-14)"> + id="metadata27603"> image/svg+xml + - + showguides="false" + inkscape:zoom="1.332054" + inkscape:cx="196.56329" + inkscape:cy="93.06112" + inkscape:window-x="1912" + inkscape:window-y="-8" + inkscape:window-maximized="1" + inkscape:current-layer="svg27599" /> + + + + + + + + + + + + + + + + + + + + + + - - - - - - - + inkscape:connector-curvature="0" + d="m 24.761156,5.6531208 c -0.612827,0 -1.217631,0.037456 -1.817078,0.090985 7.716554,1.4343965 13.561168,8.1902242 13.561168,16.3202392 0,9.175029 -7.439574,16.613266 -16.614604,16.613266 -6.322302,0 -11.8176845,-3.5338 -14.6249215,-8.728119 1.97764,8.951575 9.9470875,15.653883 19.4940985,15.653883 11.032247,0 19.974459,-8.943548 19.974459,-19.975795 0.004,-11.032253 -8.940875,-19.9744589 -19.973122,-19.9744592 z" + id="path1700" + style="fill:#1f1a17;stroke:#1f1a17;stroke-width:1.69328892;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;fill-opacity:1" /> diff --git a/client/public/images/pieces/Omega/wc.svg b/client/public/images/pieces/Omega/wc.svg index 2dfaffa5..708a5ceb 100644 --- a/client/public/images/pieces/Omega/wc.svg +++ b/client/public/images/pieces/Omega/wc.svg @@ -7,26 +7,29 @@ xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" - height="100%" - width="100%" + width="177.17" + height="177.17" + shape-rendering="geometricPrecision" + image-rendering="optimizeQuality" + fill-rule="evenodd" + clip-rule="evenodd" + viewBox="0 0 50 50" version="1.1" - viewBox="0 0 2048 2048" - id="svg6" - sodipodi:docname="wc.svg" - inkscape:version="0.92.4 5da689c313, 2019-01-14"> + id="svg27599" + sodipodi:docname="wChampion.svg" + inkscape:version="0.92.4 (5da689c313, 2019-01-14)"> + id="metadata27603"> image/svg+xml + - - - + showguides="false" + inkscape:zoom="0.9419044" + inkscape:cx="417.55145" + inkscape:cy="19.437519" + inkscape:window-x="1912" + inkscape:window-y="-8" + inkscape:window-maximized="1" + inkscape:current-layer="svg27599" /> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/client/public/images/pieces/Omega/ww.svg b/client/public/images/pieces/Omega/ww.svg index f40e874a..c77e29a2 100644 --- a/client/public/images/pieces/Omega/ww.svg +++ b/client/public/images/pieces/Omega/ww.svg @@ -7,26 +7,29 @@ xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" - height="100%" - width="100%" + width="177.17" + height="177.17" + shape-rendering="geometricPrecision" + image-rendering="optimizeQuality" + fill-rule="evenodd" + clip-rule="evenodd" + viewBox="0 0 50 50" version="1.1" - viewBox="0 0 2048 2048" - id="svg18" - sodipodi:docname="ww.svg" - inkscape:version="0.92.4 5da689c313, 2019-01-14"> + id="svg27599" + sodipodi:docname="wWizard.svg" + inkscape:version="0.92.4 (5da689c313, 2019-01-14)"> + id="metadata27603"> image/svg+xml + - - + showguides="false" + inkscape:zoom="1.332054" + inkscape:cx="196.56329" + inkscape:cy="93.06112" + inkscape:window-x="1912" + inkscape:window-y="-8" + inkscape:window-maximized="1" + inkscape:current-layer="svg27599" /> + + + + + + + + + + + + + + + + + + + + + + - - - - - - - + inkscape:connector-curvature="0" + d="m 24.761156,5.6531208 c -0.612827,0 -1.217631,0.037456 -1.817078,0.090985 7.716554,1.4343965 13.561168,8.1902242 13.561168,16.3202392 0,9.175029 -7.439574,16.613266 -16.614604,16.613266 -6.322302,0 -11.8176845,-3.5338 -14.6249215,-8.728119 1.97764,8.951575 9.9470875,15.653883 19.4940985,15.653883 11.032247,0 19.974459,-8.943548 19.974459,-19.975795 0.004,-11.032253 -8.940875,-19.9744589 -19.973122,-19.9744592 z" + id="path1700" + style="fill:#ffffff;stroke:#1f1a17;stroke-width:1.69328892;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> diff --git a/client/public/images/pieces/Tencubed/bc.svg b/client/public/images/pieces/Tencubed/bc.svg index e3d2eb68..1040316f 100644 --- a/client/public/images/pieces/Tencubed/bc.svg +++ b/client/public/images/pieces/Tencubed/bc.svg @@ -7,26 +7,29 @@ xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" - height="100%" - width="100%" + width="177.17" + height="177.17" + shape-rendering="geometricPrecision" + image-rendering="optimizeQuality" + fill-rule="evenodd" + clip-rule="evenodd" + viewBox="0 0 50 50" version="1.1" - viewBox="0 0 2048 2048" - id="svg18" - sodipodi:docname="bc.svg" - inkscape:version="0.92.4 5da689c313, 2019-01-14"> + id="svg27599" + sodipodi:docname="bChampion.svg" + inkscape:version="0.92.4 (5da689c313, 2019-01-14)"> + id="metadata27603"> image/svg+xml + - - + showguides="false" + inkscape:zoom="2.664108" + inkscape:cx="105.33637" + inkscape:cy="39.05641" + inkscape:window-x="1912" + inkscape:window-y="-8" + inkscape:window-maximized="1" + inkscape:current-layer="svg27599" /> + + + + + + + + + + + + + + + + + + + + + + + + + + - - - + transform="matrix(1.2044555,0,0,1.2044555,-1.9681825,-0.2899927)" + id="g2329" + style="stroke-width:1.40585434;stroke-miterlimit:4;stroke-dasharray:none;fill:#1f1a17;fill-opacity:1"> + + + - - + style="fill:#1f1a17;stroke:#1f1a17;stroke-width:1.40585434;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;fill-opacity:1" + inkscape:connector-curvature="0" + d="m 22.447,4.833 c 0,3.024 4.98,5.545 7.47,7.057 2.49,1.512 3.485,3.276 3.485,5.545 0,2.269 0,14.114 0,16.383 0,2.269 4.981,4.285 4.981,4.285 H 22.447" + id="path2327" /> + + + + diff --git a/client/public/images/pieces/Tencubed/bw.svg b/client/public/images/pieces/Tencubed/bw.svg index 5c6b2bb8..70e9b793 100644 --- a/client/public/images/pieces/Tencubed/bw.svg +++ b/client/public/images/pieces/Tencubed/bw.svg @@ -7,26 +7,29 @@ xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" - height="100%" - width="100%" + width="177.17" + height="177.17" + shape-rendering="geometricPrecision" + image-rendering="optimizeQuality" + fill-rule="evenodd" + clip-rule="evenodd" + viewBox="0 0 50 50" version="1.1" - viewBox="0 0 2048 2048" - id="svg16" - sodipodi:docname="bw.svg" - inkscape:version="0.92.4 5da689c313, 2019-01-14"> + id="svg27599" + sodipodi:docname="bWizard.svg" + inkscape:version="0.92.4 (5da689c313, 2019-01-14)"> + id="metadata27603"> image/svg+xml + - + showguides="false" + inkscape:zoom="1.332054" + inkscape:cx="196.56329" + inkscape:cy="93.06112" + inkscape:window-x="1912" + inkscape:window-y="-8" + inkscape:window-maximized="1" + inkscape:current-layer="svg27599" /> + + + + + + + + + + + + + + + + + + + + + + - - - - - - - + inkscape:connector-curvature="0" + d="m 24.761156,5.6531208 c -0.612827,0 -1.217631,0.037456 -1.817078,0.090985 7.716554,1.4343965 13.561168,8.1902242 13.561168,16.3202392 0,9.175029 -7.439574,16.613266 -16.614604,16.613266 -6.322302,0 -11.8176845,-3.5338 -14.6249215,-8.728119 1.97764,8.951575 9.9470875,15.653883 19.4940985,15.653883 11.032247,0 19.974459,-8.943548 19.974459,-19.975795 0.004,-11.032253 -8.940875,-19.9744589 -19.973122,-19.9744592 z" + id="path1700" + style="fill:#1f1a17;stroke:#1f1a17;stroke-width:1.69328892;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;fill-opacity:1" /> diff --git a/client/public/images/pieces/Tencubed/wc.svg b/client/public/images/pieces/Tencubed/wc.svg index 2dfaffa5..708a5ceb 100644 --- a/client/public/images/pieces/Tencubed/wc.svg +++ b/client/public/images/pieces/Tencubed/wc.svg @@ -7,26 +7,29 @@ xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" - height="100%" - width="100%" + width="177.17" + height="177.17" + shape-rendering="geometricPrecision" + image-rendering="optimizeQuality" + fill-rule="evenodd" + clip-rule="evenodd" + viewBox="0 0 50 50" version="1.1" - viewBox="0 0 2048 2048" - id="svg6" - sodipodi:docname="wc.svg" - inkscape:version="0.92.4 5da689c313, 2019-01-14"> + id="svg27599" + sodipodi:docname="wChampion.svg" + inkscape:version="0.92.4 (5da689c313, 2019-01-14)"> + id="metadata27603"> image/svg+xml + - - - + showguides="false" + inkscape:zoom="0.9419044" + inkscape:cx="417.55145" + inkscape:cy="19.437519" + inkscape:window-x="1912" + inkscape:window-y="-8" + inkscape:window-maximized="1" + inkscape:current-layer="svg27599" /> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/client/public/images/pieces/Tencubed/ww.svg b/client/public/images/pieces/Tencubed/ww.svg index f40e874a..c77e29a2 100644 --- a/client/public/images/pieces/Tencubed/ww.svg +++ b/client/public/images/pieces/Tencubed/ww.svg @@ -7,26 +7,29 @@ xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" - height="100%" - width="100%" + width="177.17" + height="177.17" + shape-rendering="geometricPrecision" + image-rendering="optimizeQuality" + fill-rule="evenodd" + clip-rule="evenodd" + viewBox="0 0 50 50" version="1.1" - viewBox="0 0 2048 2048" - id="svg18" - sodipodi:docname="ww.svg" - inkscape:version="0.92.4 5da689c313, 2019-01-14"> + id="svg27599" + sodipodi:docname="wWizard.svg" + inkscape:version="0.92.4 (5da689c313, 2019-01-14)"> + id="metadata27603"> image/svg+xml + - - + showguides="false" + inkscape:zoom="1.332054" + inkscape:cx="196.56329" + inkscape:cy="93.06112" + inkscape:window-x="1912" + inkscape:window-y="-8" + inkscape:window-maximized="1" + inkscape:current-layer="svg27599" /> + + + + + + + + + + + + + + + + + + + + + + - - - - - - - + inkscape:connector-curvature="0" + d="m 24.761156,5.6531208 c -0.612827,0 -1.217631,0.037456 -1.817078,0.090985 7.716554,1.4343965 13.561168,8.1902242 13.561168,16.3202392 0,9.175029 -7.439574,16.613266 -16.614604,16.613266 -6.322302,0 -11.8176845,-3.5338 -14.6249215,-8.728119 1.97764,8.951575 9.9470875,15.653883 19.4940985,15.653883 11.032247,0 19.974459,-8.943548 19.974459,-19.975795 0.004,-11.032253 -8.940875,-19.9744589 -19.973122,-19.9744592 z" + id="path1700" + style="fill:#ffffff;stroke:#1f1a17;stroke-width:1.69328892;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /> diff --git a/client/src/components/BaseGame.vue b/client/src/components/BaseGame.vue index fd26d872..5ab02fad 100644 --- a/client/src/components/BaseGame.vue +++ b/client/src/components/BaseGame.vue @@ -533,6 +533,8 @@ export default { for (let i=move.length -1; i >= 0; i--) this.vr.undo(move[i]); this.moves.pop(); this.cursor--; + // The board may still show the possible moves: (TODO: bad solution) + this.$refs["board"].resetCurrentAttempt(); this.inMultimove = false; }, cancelLastMove: function() { diff --git a/client/src/components/Board.vue b/client/src/components/Board.vue index 56f34880..6c26722a 100644 --- a/client/src/components/Board.vue +++ b/client/src/components/Board.vue @@ -625,6 +625,13 @@ export default { this.processArrowAttempt(e); } }, + // Called by BaseGame after partially undoing multi-moves: + resetCurrentAttempt: function() { + this.possibleMoves = []; + this.start = null; + this.click = ""; + this.selectedPiece = null; + }, processMoveAttempt: function(e) { // Obtain the move from start and end squares const [offsetX, offsetY] = diff --git a/client/src/translations/en.js b/client/src/translations/en.js index c2636745..d2ed2803 100644 --- a/client/src/translations/en.js +++ b/client/src/translations/en.js @@ -170,6 +170,7 @@ export const translations = { "Both sides of the mirror": "Both sides of the mirror", "Capture all of a kind": "Capture all of a kind", "Capture en passant": "Capture en passant", + "Capture on the edge": "Capture on the edge", "Capture powers": "Capture powers", "Captures reborn": "Captures reborn", "Change colors": "Change colors", @@ -200,6 +201,7 @@ export const translations = { "Move like a knight (v2)": "Move like a knight (v2)", "Neverending rows": "Neverending rows", "No-check mode": "No-check mode", + "Occupy the enemy palace": "Occupy the enemy palace", "Pawns move diagonally": "Pawns move diagonally", "Play at the same time": "Play at the same time", "Powerful pieces": "Powerful pieces", diff --git a/client/src/translations/es.js b/client/src/translations/es.js index cb9b15de..9af8c4b8 100644 --- a/client/src/translations/es.js +++ b/client/src/translations/es.js @@ -170,6 +170,7 @@ export const translations = { "Both sides of the mirror": "Ambos lados del espejo", "Capture all of a kind": "Capturar todo del mismo tipo", "Capture en passant": "Capturar en passant", + "Capture on the edge": "Capturar en el borde", "Capture powers": "Capturar los poderes", "Captures reborn": "Las capturas renacen", "Change colors": "Cambiar colores", @@ -200,6 +201,7 @@ export const translations = { "Move like a knight (v2)": "Moverse como un caballo (v2)", "Neverending rows": "Filas interminables", "No-check mode": "Modo sin jaque", + "Occupy the enemy palace": "Ocupar el palacio enemigo", "Pawns move diagonally": "Peones se mueven en diagonal", "Play at the same time": "Jugar al mismo tiempo", "Powerful pieces": "Piezas poderosas", diff --git a/client/src/translations/fr.js b/client/src/translations/fr.js index 5b2fb42b..95d115c6 100644 --- a/client/src/translations/fr.js +++ b/client/src/translations/fr.js @@ -170,6 +170,7 @@ export const translations = { "Both sides of the mirror": "Les deux côté du miroir", "Capture all of a kind": "Capturez tout d'un même type", "Capture en passant": "Capturer en passant", + "Capture on the edge": "Capturer sur le bord", "Capture powers": "Capturer les pouvoirs", "Captures reborn": "Les captures renaissent", "Change colors": "Changer les couleurs", @@ -200,6 +201,7 @@ export const translations = { "Move like a knight (v2)": "Bouger comme un cavalier (v2)", "Neverending rows": "Rangées sans fin", "No-check mode": "Mode sans échec", + "Occupy the enemy palace": "Occuper le palais ennemi", "Pawns move diagonally": "Les pions vont en diagonale", "Play at the same time": "Jouer en même temps", "Powerful pieces": "Pièces puissantes", diff --git a/client/src/translations/rules/Baroque/en.pug b/client/src/translations/rules/Baroque/en.pug index 5e5a752c..e368afa5 100644 --- a/client/src/translations/rules/Baroque/en.pug +++ b/client/src/translations/rules/Baroque/en.pug @@ -1,7 +1,6 @@ p.boxed - | Most pieces look the same but behave very differently. - | They generally move like an orthodox queen, - | but capturing rules are more complex. + | Pieces generally move like an orthodox queen, + | but capturing rules are quite complex. p | Note: 'Baroque' is the initial name thought by the author, diff --git a/client/src/translations/rules/Baroque/es.pug b/client/src/translations/rules/Baroque/es.pug index bde85c4e..c37396f4 100644 --- a/client/src/translations/rules/Baroque/es.pug +++ b/client/src/translations/rules/Baroque/es.pug @@ -1,6 +1,6 @@ -p.boxed - | La mayoría de las piezas son conocidas pero se mueven de manera diferente ; - | generalmente como una dama ortodoxa, pero las capturas son complejas. +p.boxed. + Las piezas generalmente se mueven como una dama ortodoxa, y las capturas + son bastante complejas p | Nota: el nombre elegido inicialmente por el autor es 'Baroque', diff --git a/client/src/translations/rules/Baroque/fr.pug b/client/src/translations/rules/Baroque/fr.pug index b2554faf..9cc500db 100644 --- a/client/src/translations/rules/Baroque/fr.pug +++ b/client/src/translations/rules/Baroque/fr.pug @@ -1,6 +1,6 @@ p.boxed - | La plupart des pièces sont connues mais se déplacent différemment ; - | en général comme une dame orthodoxe, mais les captures sont complexes. + | Les pièces se déplacent en général comme une dame orthodoxe, + | et les captures sont assez complexes. p | Note : le nom initialement choisit par l'auteur est 'Baroque', diff --git a/client/src/translations/rules/Maxima/en.pug b/client/src/translations/rules/Maxima/en.pug new file mode 100644 index 00000000..c1a22b1d --- /dev/null +++ b/client/src/translations/rules/Maxima/en.pug @@ -0,0 +1,20 @@ +p.boxed. + Pieces movements and captures are complex. + You can win by occupying the two squares of the last rank. + +figure.diagram-container + .diagram + | fen:xxx2xxx/1g1qk1g1/1bnmrnb1/dppppppd/8/8/8/DPPPPPPD/1BNMRNB1/1G1QK1G1/xxx2xxx: + figcaption Standard deterministic position + +p. + The pawns, queen, rook, inverted rook and knights are respectively called + Pincers, Withdrawer, Coordinator, Immobilizer and Long Leapers, and behave + exactly as in Baroque chess - so I won't describe them here, please read the + Baroque rules. + +p. + + guard mage king + + diff --git a/client/src/translations/rules/Maxima/es.pug b/client/src/translations/rules/Maxima/es.pug new file mode 100644 index 00000000..1333ed77 --- /dev/null +++ b/client/src/translations/rules/Maxima/es.pug @@ -0,0 +1 @@ +TODO diff --git a/client/src/translations/rules/Maxima/fr.pug b/client/src/translations/rules/Maxima/fr.pug new file mode 100644 index 00000000..1333ed77 --- /dev/null +++ b/client/src/translations/rules/Maxima/fr.pug @@ -0,0 +1 @@ +TODO diff --git a/client/src/translations/rules/Rococo/en.pug b/client/src/translations/rules/Rococo/en.pug index 7000378b..317024f5 100644 --- a/client/src/translations/rules/Rococo/en.pug +++ b/client/src/translations/rules/Rococo/en.pug @@ -1,7 +1,6 @@ p.boxed. - Most pieces look as usual but behave differently. - They generally move like an orthodox queen, - but capturing rules are more complex. + Pieces generally move like an orthodox queen, + but capture according to complexe rules. p. This variant comes from an attempt to fix some issues with Baroque variant, diff --git a/client/src/translations/rules/Rococo/es.pug b/client/src/translations/rules/Rococo/es.pug index c60d8709..e340b2d9 100644 --- a/client/src/translations/rules/Rococo/es.pug +++ b/client/src/translations/rules/Rococo/es.pug @@ -1,7 +1,6 @@ p.boxed. - La mayoría de las piezas parecen familiares pero se comportan de manera - diferente. Suelen moverse como una dama ortodoxa, - pero captura de acuerdo con reglas bastante complejas. + Las piezas se mueven generalmente como una dama ortodoxa, + pero capturan de acuerdo con reglas complejas. p. Esta variante proviene de un intento de resolver problemas con la diff --git a/client/src/translations/rules/Rococo/fr.pug b/client/src/translations/rules/Rococo/fr.pug index 4446030b..5c9d8f84 100644 --- a/client/src/translations/rules/Rococo/fr.pug +++ b/client/src/translations/rules/Rococo/fr.pug @@ -1,7 +1,6 @@ p.boxed. - La plupart des pièces semblent familières mais se comportent différemment. - Elles se déplacent en général comme une dame orthodoxe, - mais capturent selon des règles assez complexes. + Les pièces se déplacent en général comme une dame orthodoxe, + mais capturent selon des règles complexes. p. Cette variante provient d'une tentative de résoudre des problèmes avec la diff --git a/client/src/variants/Baroque.js b/client/src/variants/Baroque.js index 74617cfb..1e02cdf7 100644 --- a/client/src/variants/Baroque.js +++ b/client/src/variants/Baroque.js @@ -425,8 +425,9 @@ export class BaroqueRules extends ChessRules { if ( (sameRow && move.end.y == y) || (sameColumn && move.end.x == x) - ) + ) { return true; + } } } } @@ -454,8 +455,9 @@ export class BaroqueRules extends ChessRules { if ( this.getPiece(i, j) == V.KNIGHT && !this.isImmobilized([i, j]) - ) + ) { return true; + } continue outerLoop; } // [else] Our color, diff --git a/client/src/variants/Maxima.js b/client/src/variants/Maxima.js new file mode 100644 index 00000000..ab97a217 --- /dev/null +++ b/client/src/variants/Maxima.js @@ -0,0 +1,832 @@ +import { ChessRules, PiPo, Move } from "@/base_rules"; +import { ArrayFun } from "@/utils/array"; +import { shuffle } from "@/utils/alea"; + +export class MaximaRules extends ChessRules { + static get HasFlags() { + return false; + } + + static get HasEnpassant() { + return false; + } + + static get PIECES() { + return ChessRules.PIECES.concat([V.IMMOBILIZER, V.MAGE, V.GUARD]); + } + + getPpath(b) { + if (b[0] == 'x') return "Maxima/nothing"; + if (['m','d','g'].includes(b[1])) + return "Maxima/" + b; + return b; + } + + // For space next to the palaces: + static get NOTHING() { + return "xx"; + } + + static board2fen(b) { + if (b[0] == 'x') return 'x'; + return ChessRules.board2fen(b); + } + + static fen2board(f) { + if (f == 'x') return V.NOTHING; + return ChessRules.fen2board(f); + } + + // TODO: the wall position should be checked too + static IsGoodPosition(position) { + if (position.length == 0) return false; + const rows = position.split("/"); + if (rows.length != V.size.x) return false; + let kings = { "k": 0, "K": 0 }; + for (let row of rows) { + let sumElts = 0; + for (let i = 0; i < row.length; i++) { + if (['K','k'].includes(row[i])) kings[row[i]]++; + if (['x'].concat(V.PIECES).includes(row[i].toLowerCase())) sumElts++; + else { + const num = parseInt(row[i]); + if (isNaN(num)) return false; + sumElts += num; + } + } + if (sumElts != V.size.y) return false; + } + if (Object.values(kings).some(v => v != 1)) return false; + return true; + } + + // No castling, but checks, so keep track of kings + setOtherVariables(fen) { + this.kingPos = { w: [-1, -1], b: [-1, -1] }; + const fenParts = fen.split(" "); + const position = fenParts[0].split("/"); + for (let i = 0; i < position.length; i++) { + let k = 0; + for (let j = 0; j < position[i].length; j++) { + switch (position[i].charAt(j)) { + case "k": + this.kingPos["b"] = [i, k]; + break; + case "K": + this.kingPos["w"] = [i, k]; + break; + default: { + const num = parseInt(position[i].charAt(j)); + if (!isNaN(num)) k += num - 1; + } + } + k++; + } + } + } + + static get size() { + return { x: 11, y: 8 }; + } + + static OnBoard(x, y) { + return ( + (x >= 1 && x <= 9 && y >= 0 && y <= 7) || + ([3, 4].includes(y) && [0, 10].includes(x)) + ); + } + + static get IMMOBILIZER() { + return "m"; + } + static get MAGE() { + return 'g'; + } + static get GUARD() { + return 'd'; + } + // Although other pieces keep their names here for coding simplicity, + // keep in mind that: + // - a "rook" is a coordinator, capturing by coordinating with the king + // - a "knight" is a long-leaper, capturing as in draughts + // - a "bishop" is a chameleon, capturing as its prey + // - a "queen" is a withdrawer, capturing by moving away from pieces + + // Is piece on square (x,y) immobilized? + isImmobilized([x, y]) { + const piece = this.getPiece(x, y); + if (piece == V.MAGE) + // Mages are not immobilized: + return false; + const oppCol = V.GetOppCol(this.getColor(x, y)); + const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]); + for (let step of adjacentSteps) { + const [i, j] = [x + step[0], y + step[1]]; + if ( + V.OnBoard(i, j) && + this.board[i][j] != V.EMPTY && + this.getColor(i, j) == oppCol + ) { + const oppPiece = this.getPiece(i, j); + if (oppPiece == V.IMMOBILIZER) return [i, j]; + // Only immobilizers are immobilized by chameleons: + if (oppPiece == V.BISHOP && piece == V.IMMOBILIZER) return [i, j]; + } + } + return null; + } + + getPotentialMovesFrom([x, y]) { + // Pre-check: is thing on this square immobilized? + const imSq = this.isImmobilized([x, y]); + const piece = this.getPiece(x, y); + if (!!imSq && piece != V.KING) { + // Only option is suicide, if I'm not a king: + return [ + new Move({ + start: { x: x, y: y }, + end: { x: imSq[0], y: imSq[1] }, + appear: [], + vanish: [ + new PiPo({ + x: x, + y: y, + c: this.getColor(x, y), + p: this.getPiece(x, y) + }) + ] + }) + ]; + } + let moves = undefined; + switch (piece) { + case V.IMMOBILIZER: + moves = this.getPotentialImmobilizerMoves([x, y]); + break; + case V.GUARD: + moves = this.getPotentialGuardMoves([x, y]); + break; + case V.MAGE: + moves = this.getPotentialMageMoves([x, y]); + break; + default: + moves = super.getPotentialMovesFrom([x, y]); + } + const pX = (this.turn == 'w' ? 10 : 0); + if (this.board[pX][3] == V.EMPTY && this.board[pX][4] == V.EMPTY) + return moves; + // Filter out moves resulting in self palace occupation: + // NOTE: cannot invade own palace but still check the king there. + const pY = (this.board[pX][3] == V.EMPTY ? 4 : 3); + return moves.filter(m => m.end.x != pX || m.end.y != pY); + } + + getSlideNJumpMoves([x, y], steps, oneStep, mageInitSquare, onlyTake) { + const piece = !mageInitSquare ? this.getPiece(x, y) : V.MAGE; + const initSquare = mageInitSquare || [x, y]; + let moves = []; + outerLoop: for (let step of steps) { + let i = x + step[0]; + let j = y + step[1]; + if (piece == V.KING) j = j % V.size.y; + while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) { + if (!onlyTake) moves.push(this.getBasicMove(initSquare, [i, j])); + if (!!oneStep) continue outerLoop; + i += step[0]; + j += step[1]; + } + // Only king, guard and mage + chameleon can take on occupied square: + if ( + V.OnBoard(i, j) + && + this.canTake(initSquare, [i, j]) + && + ( + [V.KING, V.GUARD, V.MAGE].includes(piece) || + (piece == V.BISHOP && this.getPiece(i, j) === onlyTake) + ) + ) { + moves.push(this.getBasicMove(initSquare, [i, j])); + } + } + return moves; + } + + // Modify capturing moves among listed pawn moves + addPawnCaptures(moves, byChameleon) { + const steps = V.steps[V.ROOK]; + const color = this.turn; + const oppCol = V.GetOppCol(color); + moves.forEach(m => { + if (!!byChameleon && m.start.x != m.end.x && m.start.y != m.end.y) + // Chameleon not moving as pawn + return; + // 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 ( + V.OnBoard(sq2[0], sq2[1]) && + this.board[sq2[0]][sq2[1]] != V.EMPTY && + this.getColor(sq2[0], sq2[1]) == color + ) { + // Potential capture + const sq1 = [m.end.x + step[0], m.end.y + step[1]]; + if ( + this.board[sq1[0]][sq1[1]] != V.EMPTY && + this.getColor(sq1[0], sq1[1]) == oppCol + ) { + const piece1 = this.getPiece(sq1[0], sq1[1]); + if (!byChameleon || piece1 == V.PAWN) { + m.vanish.push( + new PiPo({ + x: sq1[0], + y: sq1[1], + c: oppCol, + p: piece1 + }) + ); + } + } + } + } + }); + } + + // "Pincer" + getPotentialPawnMoves([x, y]) { + let moves = super.getPotentialRookMoves([x, y]); + this.addPawnCaptures(moves); + return moves; + } + + addRookCaptures(moves, byChameleon) { + const color = this.turn; + const oppCol = V.GetOppCol(color); + const kp = this.kingPos[color]; + moves.forEach(m => { + // Check piece-king rectangle (if any) corners for enemy pieces + if (m.end.x == kp[0] || m.end.y == kp[1]) return; //"flat rectangle" + const corner1 = [m.end.x, kp[1]]; + const corner2 = [kp[0], m.end.y]; + for (let [i, j] of [corner1, corner2]) { + if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == oppCol) { + const piece = this.getPiece(i, j); + if (!byChameleon || piece == V.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; + } + + getKnightCaptures(startSquare, byChameleon) { + // Look in every direction for captures + const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]); + const color = this.turn; + const oppCol = V.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]]; + while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) { + i += step[0]; + j += step[1]; + } + if ( + !V.OnBoard(i, j) || + this.getColor(i, j) == color || + (!!byChameleon && this.getPiece(i, j) != V.KNIGHT) + ) { + continue; + } + // 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 (V.OnBoard(cur[0], cur[1])) { + if (this.board[last[0]][last[1]] != V.EMPTY) { + const oppPiece = this.getPiece(last[0], last[1]); + if (!!byChameleon && oppPiece != V.KNIGHT) continue outerLoop; + // Something to eat: + vanished.push( + new PiPo({ x: last[0], y: last[1], c: oppCol, p: oppPiece }) + ); + } + if (this.board[cur[0]][cur[1]] != V.EMPTY) { + if ( + this.getColor(cur[0], cur[1]) == color || + this.board[last[0]][last[1]] != V.EMPTY + ) { + //TODO: redundant test + continue outerLoop; + } + } else { + moves.push( + new Move({ + appear: [new PiPo({ x: cur[0], y: cur[1], c: color, p: piece })], + vanish: JSON.parse(JSON.stringify(vanished)), //TODO: required? + start: { x: x, y: y }, + end: { x: cur[0], y: cur[1] } + }) + ); + } + last = [last[0] + step[0], last[1] + step[1]]; + cur = [cur[0] + step[0], cur[1] + step[1]]; + } + } + return moves; + } + + // Long-leaper + getPotentialKnightMoves(sq) { + return super.getPotentialQueenMoves(sq).concat(this.getKnightCaptures(sq)); + } + + // Chameleon + getPotentialBishopMoves([x, y]) { + let moves = super + .getPotentialQueenMoves([x, y]) + .concat(this.getKnightCaptures([x, y], "asChameleon")) + .concat(this.getPotentialGuardMoves([x, y], "asChameleon")) + .concat(this.getPotentialMageMoves([x, y], "asChameleon")); + // No "king capture" because king cannot remain under check + this.addPawnCaptures(moves, "asChameleon"); + this.addRookCaptures(moves, "asChameleon"); + this.addQueenCaptures(moves, "asChameleon"); + // Post-processing: merge similar moves, concatenating vanish arrays + let mergedMoves = {}; + moves.forEach(m => { + const key = m.end.x + V.size.x * m.end.y; + if (!mergedMoves[key]) mergedMoves[key] = m; + else { + for (let i = 1; i < m.vanish.length; i++) + mergedMoves[key].vanish.push(m.vanish[i]); + } + }); + return Object.values(mergedMoves); + } + + addQueenCaptures(moves, byChameleon) { + if (moves.length == 0) return; + const [x, y] = [moves[0].start.x, moves[0].start.y]; + const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]); + let capturingDirections = []; + const color = this.turn; + const oppCol = V.GetOppCol(color); + adjacentSteps.forEach(step => { + const [i, j] = [x + step[0], y + step[1]]; + if ( + V.OnBoard(i, j) && + this.board[i][j] != V.EMPTY && + this.getColor(i, j) == oppCol && + (!byChameleon || this.getPiece(i, j) == V.QUEEN) + ) { + capturingDirections.push(step); + } + }); + moves.forEach(m => { + 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 + ]; + // TODO: this test should be done only once per direction + 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({ + x: i, + y: j, + p: this.getPiece(i, j), + c: oppCol + }) + ); + } + }); + } + + // Withdrawer + getPotentialQueenMoves(sq) { + let moves = super.getPotentialQueenMoves(sq); + this.addQueenCaptures(moves); + return moves; + } + + getPotentialImmobilizerMoves(sq) { + // Immobilizer doesn't capture + return super.getPotentialQueenMoves(sq); + } + + getPotentialKingMoves(sq) { + return this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep"); + } + + getPotentialGuardMoves(sq, byChameleon) { + const onlyTake = !byChameleon ? null : V.GUARD; + return ( + this.getSlideNJumpMoves( + sq, + V.steps[V.ROOK].concat(V.steps[V.BISHOP]), + "oneStep", + null, + onlyTake + ) + ); + } + + getNextMageSteps(step) { + if (step[0] == -1) { + if (step[1] == -1) return [[-1, 0], [0, -1]]; + return [[-1, 0], [0, 1]]; + } + if (step[1] == -1) return [[1, 0], [0, -1]]; + return [[1, 0], [0, 1]]; + } + + getPotentialMageMoves([x, y], byChameleon) { + const oppCol = V.GetOppCol(this.turn); + const onlyTake = !byChameleon ? null : V.MAGE; + let moves = []; + for (let step of V.steps[V.BISHOP]) { + let [i, j] = [x + step[0], y + step[1]]; + if (!V.OnBoard(i, j)) continue; + if (this.board[i][j] != V.EMPTY) { + if ( + this.getColor(i, j) == oppCol && + (!onlyTake || this.getPiece(i, j) == V.MAGE) + ) { + // Capture + moves.push(this.getBasicMove([x, y], [i, j])); + } + } + else { + if (!onlyTake) moves.push(this.getBasicMove([x, y], [i, j])); + // Continue orthogonally: + const stepO = this.getNextMageSteps(step); + Array.prototype.push.apply( + moves, + this.getSlideNJumpMoves([i, j], stepO, null, [x, y], onlyTake) + ); + } + } + return moves; + } + + isAttacked(sq, color) { + return ( + super.isAttacked(sq, color) || + this.isAttackedByGuard(sq, color) || + this.isAttackedByMage(sq, color) + ); + } + + isAttackedByPawn([x, y], color) { + // Square (x,y) must be surroundable by two enemy pieces, + // and one of them at least should be a pawn (moving). + const dirs = [ + [1, 0], + [0, 1] + ]; + const steps = V.steps[V.ROOK]; + for (let dir of dirs) { + const [i1, j1] = [x - dir[0], y - dir[1]]; //"before" + const [i2, j2] = [x + dir[0], y + dir[1]]; //"after" + if (V.OnBoard(i1, j1) && V.OnBoard(i2, j2)) { + if ( + ( + this.board[i1][j1] != V.EMPTY && + this.getColor(i1, j1) == color && + this.board[i2][j2] == V.EMPTY + ) + || + ( + this.board[i2][j2] != V.EMPTY && + this.getColor(i2, j2) == color && + this.board[i1][j1] == V.EMPTY + ) + ) { + // Search a movable enemy pawn landing on the empty square + for (let step of steps) { + let [ii, jj] = this.board[i1][j1] == V.EMPTY ? [i1, j1] : [i2, j2]; + let [i3, j3] = [ii + step[0], jj + step[1]]; + while (V.OnBoard(i3, j3) && this.board[i3][j3] == V.EMPTY) { + i3 += step[0]; + j3 += step[1]; + } + if ( + V.OnBoard(i3, j3) && + this.getColor(i3, j3) == color && + this.getPiece(i3, j3) == V.PAWN && + !this.isImmobilized([i3, j3]) + ) { + return true; + } + } + } + } + } + return false; + } + + isAttackedByRook([x, y], color) { + // King must be on same column or row, + // and a rook should be able to reach a capturing square + const sameRow = x == this.kingPos[color][0]; + const sameColumn = y == this.kingPos[color][1]; + if (sameRow || sameColumn) { + // Look for the enemy rook (maximum 1) + for (let i = 0; i < V.size.x; i++) { + for (let j = 0; j < V.size.y; j++) { + if ( + this.board[i][j] != V.EMPTY && + this.getColor(i, j) == color && + this.getPiece(i, j) == V.ROOK + ) { + if (this.isImmobilized([i, j])) + // Because only one rook: + return false; + // Can it reach a capturing square? Easy but quite suboptimal way + // (TODO: generate all moves (turn is OK)) + const moves = this.getPotentialMovesFrom([i, j]); + for (let move of moves) { + if ( + (sameRow && move.end.y == y) || + (sameColumn && move.end.x == x) + ) { + return true; + } + } + } + } + } + } + return false; + } + + isAttackedByKnight([x, y], color) { + // Square (x,y) must be on same line as a knight, + // and there must be empty square(s) behind. + const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]); + outerLoop: for (let step of steps) { + const [i0, j0] = [x + step[0], y + step[1]]; + if (V.OnBoard(i0, j0) && this.board[i0][j0] == V.EMPTY) { + // Try in opposite direction: + let [i, j] = [x - step[0], y - step[1]]; + while (V.OnBoard(i, j)) { + while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) { + i -= step[0]; + j -= step[1]; + } + if (V.OnBoard(i, j)) { + if (this.getColor(i, j) == color) { + if ( + this.getPiece(i, j) == V.KNIGHT && + !this.isImmobilized([i, j]) + ) { + return true; + } + continue outerLoop; + } + // [else] Our color, + // could be captured *if there was an empty space* + if (this.board[i + step[0]][j + step[1]] != V.EMPTY) + continue outerLoop; + i -= step[0]; + j -= step[1]; + } + } + } + } + return false; + } + + isAttackedByBishop([x, y], color) { + // We cheat a little here: since this function is used exclusively for + // the king, it's enough to check the immediate surrounding of the square. + const adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]); + for (let step of adjacentSteps) { + const [i, j] = [x + step[0], y + step[1]]; + if ( + V.OnBoard(i, j) && + this.board[i][j] != V.EMPTY && + this.getColor(i, j) == color && + this.getPiece(i, j) == V.BISHOP && + !this.isImmobilized([i, j]) + ) { + return true; + } + } + return false; + } + + isAttackedByQueen([x, y], color) { + // 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 adjacentSteps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]); + for (let step of adjacentSteps) { + const sq2 = [x + 2 * step[0], y + 2 * step[1]]; + if (V.OnBoard(sq2[0], sq2[1]) && this.board[sq2[0]][sq2[1]] == V.EMPTY) { + const sq1 = [x + step[0], y + step[1]]; + if ( + this.board[sq1[0]][sq1[1]] != V.EMPTY && + this.getColor(sq1[0], sq1[1]) == color && + this.getPiece(sq1[0], sq1[1]) == V.QUEEN && + !this.isImmobilized(sq1) + ) { + return true; + } + } + } + return false; + } + + isAttackedByKing([x, y], color) { + for (let step of V.steps[V.KNIGHT]) { + let rx = x + step[0], + // Circular board for king-knight: + ry = (y + step[1]) % V.size.y; + if ( + V.OnBoard(rx, ry) && + this.getPiece(rx, ry) === V.KING && + this.getColor(rx, ry) == color && + !this.isImmobilized([rx, ry]) + ) { + return true; + } + } + return false; + } + + isAttackedByGuard(sq, color) { + return ( + super.isAttackedBySlideNJump( + sq, + color, + V.GUARD, + V.steps[V.ROOK].concat(V.steps[V.BISHOP]), + "oneStep" + ) + ); + } + + getNextMageCheck(step) { + if (step[0] == 0) { + if (step[1] == 1) return [[1, 1], [-1, 1]]; + return [[-1, -1], [1, -1]]; + } + if (step[0] == -1) return [[-1, -1], [-1, 1]]; + return [[1, 1], [1, -1]]; + } + + isAttackedByMage([x, y], color) { + for (let step of V.steps[V.BISHOP]) { + const [i, j] = [x + step[0], y + step[1]]; + if ( + V.OnBoard(i, j) && + this.board[i][j] != V.EMPTY && + this.getColor(i, j) == color && + this.getPiece(i, j) == V.MAGE + ) { + return true; + } + } + for (let step of V.steps[V.ROOK]) { + let [i, j] = [x + step[0], y + step[1]]; + const stepM = this.getNextMageCheck(step); + while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) { + for (let s of stepM) { + const [ii, jj] = [i + s[0], j + s[1]]; + if ( + V.OnBoard(ii, jj) && + this.board[ii][jj] != V.EMPTY && + this.getColor(ii, jj) == color && + this.getPiece(ii, jj) == V.MAGE + ) { + return true; + } + } + i += step[0]; + j += step[1]; + } + } + return false; + } + + getCurrentScore() { + const color = this.turn; + const getScoreLost = () => { + // Result if I lose: + return color == "w" ? "0-1" : "1-0"; + }; + if (!this.atLeastOneMove()) { + // No valid move: I lose or draw + if (this.underCheck(color)) return getScoreLost(); + return "1/2"; + } + // I lose also if no pieces left (except king) + let piecesLeft = 0; + outerLoop: for (let i=0; i 1 ? "x" : "") + finalSquare; + else notation = move.appear[0].p.toUpperCase() + finalSquare; + // Add a capture mark (not describing what is captured...): + if (move.vanish.length > 1 && move.appear[0].p != V.KING) notation += "X"; + return notation; + } +}; diff --git a/client/src/variants/Omega.js b/client/src/variants/Omega.js index 5431198b..258bc807 100644 --- a/client/src/variants/Omega.js +++ b/client/src/variants/Omega.js @@ -36,6 +36,7 @@ export class OmegaRules extends ChessRules { return ([V.CHAMPION, V.WIZARD].includes(b[1]) ? "Omega/" : "") + b; } + // TODO: the wall position should be checked too static IsGoodPosition(position) { if (position.length == 0) return false; const rows = position.split("/"); @@ -161,21 +162,19 @@ export class OmegaRules extends ChessRules { // The second bishop must be on a square of different color let randIndex_tmp = 2 * randInt(5) + 1; const bishop2Pos = positions[randIndex_tmp]; - positions.splice(Math.max(randIndex, randIndex_tmp), 1); - positions.splice(Math.min(randIndex, randIndex_tmp), 1); // Get random squares for champions - randIndex = 2 * randInt(4); - let bishopSameColorPos = (bishop1Pos % 2 == 0 ? bishop1Pos : bishop2Pos); - if (randIndex >= bishopSameColorPos) randIndex += 2; - const champion1Pos = positions[randIndex]; + let randIndexC = 2 * randInt(4); + if (randIndexC >= bishop1Pos) randIndexC += 2; + const champion1Pos = positions[randIndexC]; // The second champion must be on a square of different color - randIndex_tmp = 2 * randInt(4) + 1; - bishopSameColorPos = (bishop1Pos % 2 == 0 ? bishop1Pos : bishop2Pos); - if (randIndex_tmp >= bishopSameColorPos) randIndex_tmp += 2; - const champion2Pos = positions[randIndex_tmp]; - positions.splice(Math.max(randIndex, randIndex_tmp), 1); - positions.splice(Math.min(randIndex, randIndex_tmp), 1); + let randIndex_tmpC = 2 * randInt(4) + 1; + if (randIndex_tmpC >= bishop2Pos) randIndex_tmpC += 2; + const champion2Pos = positions[randIndex_tmpC]; + + let usedIndices = [randIndex, randIndex_tmp, randIndexC, randIndex_tmpC]; + usedIndices.sort(); + for (let i = 3; i >= 0; i--) positions.splice(usedIndices[i], 1); // Get random squares for other pieces randIndex = randInt(6); @@ -204,7 +203,7 @@ export class OmegaRules extends ChessRules { pieces[c][knight2Pos] = "n"; pieces[c][rook2Pos] = "r"; pieces[c][champion2Pos] = "c"; - flags += V.CoordToColumn(rook1Pos) + V.CoordToColumn(rook2Pos); + flags += V.CoordToColumn(rook1Pos+1) + V.CoordToColumn(rook2Pos+1); } // Add turn + flags + enpassant return ( @@ -231,6 +230,7 @@ export class OmegaRules extends ChessRules { canTake([x1, y1], [x2, y2]) { return ( // Cannot take wall :) + // NOTE: this check is useful only for pawns where OnBoard() isn't used this.board[x2][y2] != V.NOTHING && this.getColor(x1, y1) !== this.getColor(x2, y2) ); diff --git a/client/src/variants/Rococo.js b/client/src/variants/Rococo.js index 8489ae90..0cfb5dc7 100644 --- a/client/src/variants/Rococo.js +++ b/client/src/variants/Rococo.js @@ -131,8 +131,9 @@ export class RococoRules extends ChessRules { getPotentialMovesFrom([x, y]) { // Pre-check: is thing on this square immobilized? const imSq = this.isImmobilized([x, y]); - if (!!imSq) { - // Only option is suicide: + const piece = this.getPiece(x, y); + if (!!imSq && piece != V.KING) { + // Only option is suicide, if I'm not a king: return [ new Move({ start: { x: x, y: y }, @@ -150,7 +151,7 @@ export class RococoRules extends ChessRules { ]; } let moves = []; - switch (this.getPiece(x, y)) { + switch (piece) { case V.IMMOBILIZER: moves = this.getPotentialImmobilizerMoves([x, y]); break; diff --git a/server/db/populate.sql b/server/db/populate.sql index 74612223..6a81e1ca 100644 --- a/server/db/populate.sql +++ b/server/db/populate.sql @@ -44,6 +44,7 @@ insert or ignore into Variants (name, description) values ('Losers', 'Get strong at self-mate'), ('Magnetic', 'Laws of attraction'), ('Marseille', 'Double moves'), + ('Maxima', 'Occupy the enemy palace'), ('Monster', 'White move twice'), ('Omega', 'A wizard in the corner'), ('Orda', 'Mongolian Horde'), @@ -52,6 +53,7 @@ insert or ignore into Variants (name, description) values ('Racingkings', 'Kings cross the 8x8 board'), ('Rifle', 'Shoot pieces'), ('Recycle', 'Reuse pieces'), + ('Rococo', 'Capture on the edge'), ('Royalrace', 'Kings cross the 11x11 board'), ('Rugby', 'Transform an essay'), ('Schess', 'Seirawan-Harper Chess'),