Prepare some more variants (unfinished)

[vchess.git] / public / javascripts / variants / Wildebeest.js

diff --git a/public/javascripts/variants/Wildebeest.js b/public/javascripts/variants/Wildebeest.js
index 5bfa87b..ef3779a 100644 (file)
--- a/public/javascripts/variants/Wildebeest.js
+++ b/public/javascripts/variants/Wildebeest.js
@@ -2,27 +2,60 @@ class WildebeestRules extends ChessRules
 {
        static getPpath(b)
        {
-               const V = VariantRules;
                return ([V.CAMEL,V.WILDEBEEST].includes(b[1]) ? "Wildebeest/" : "") + b;
        }
 
-       static get size() { return [10,11]; }
+       static get size() { return {x:10,y:11}; }
 
        static get CAMEL() { return 'c'; }
        static get WILDEBEEST() { return 'w'; }
 
-       static get steps() {
+       static get PIECES()
+       {
+               return ChessRules.PIECES.concat([V.CAMEL,V.WILDEBEEST]);
+       }
+
+       static get steps()
+       {
                return Object.assign(
                        ChessRules.steps, //add camel moves:
                        {'c': [ [-3,-1],[-3,1],[-1,-3],[-1,3],[1,-3],[1,3],[3,-1],[3,1] ]}
                );
        }
 
+       // There may be 2 enPassant squares (if pawn jump 3 squares)
+       getEnpassantFen()
+       {
+               const L = this.epSquares.length;
+               if (!this.epSquares[L-1])
+                       return "-"; //no en-passant
+               let res = "";
+               this.epSquares[L-1].forEach(sq => {
+                       res += V.CoordsToSquare(sq) + ",";
+               });
+               return res.slice(0,-1); //remove last comma
+       }
+
        // En-passant after 2-sq or 3-sq jumps
-       getEpSquare(move)
+       getEpSquare(moveOrSquare)
        {
+               if (!moveOrSquare)
+                       return undefined;
+               if (typeof moveOrSquare === "string")
+               {
+                       const square = moveOrSquare;
+                       if (square == "-")
+                               return undefined;
+                       let res = [];
+                       square.split(",").forEach(sq => {
+                               res.push(V.SquareToCoords(sq));
+                       });
+                       return res;
+               }
+               // Argument is a move:
+               const move = moveOrSquare;
                const [sx,sy,ex] = [move.start.x,move.start.y,move.end.x];
-               if (this.getPiece(sx,sy) == VariantRules.PAWN && Math.abs(sx - ex) >= 2)
+               if (this.getPiece(sx,sy) == V.PAWN && Math.abs(sx - ex) >= 2)
                {
                        const step = (ex-sx) / Math.abs(ex-sx);
                        let res = [{
@@ -45,9 +78,9 @@ class WildebeestRules extends ChessRules
        {
                switch (this.getPiece(x,y))
                {
-                       case VariantRules.CAMEL:
+                       case V.CAMEL:
                                return this.getPotentialCamelMoves([x,y]);
-                       case VariantRules.WILDEBEEST:
+                       case V.WILDEBEEST:
                                return this.getPotentialWildebeestMoves([x,y]);
                        default:
                                return super.getPotentialMovesFrom([x,y])
@@ -59,8 +92,7 @@ class WildebeestRules extends ChessRules
        {
                const color = this.turn;
                let moves = [];
-               const V = VariantRules;
-               const [sizeX,sizeY] = VariantRules.size;
+               const [sizeX,sizeY] = [V.size.x,V.size.y];
                const shift = (color == "w" ? -1 : 1);
                const startRanks = (color == "w" ? [sizeX-2,sizeX-3] : [1,2]);
                const lastRank = (color == "w" ? 0 : sizeX-1);
@@ -127,13 +159,12 @@ class WildebeestRules extends ChessRules
                                // TODO: some redundant checks
                                if (epsq.x == x+shift && Math.abs(epsq.y - y) == 1)
                                {
-                                       let epStep = epsq.y - y;
-                                       var enpassantMove = this.getBasicMove([x,y], [x+shift,y+epStep]);
+                                       var enpassantMove = this.getBasicMove([x,y], [x+shift,epsq.y]);
                                        enpassantMove.vanish.push({
                                                x: x,
-                                               y: y+epStep,
+                                               y: epsq.y,
                                                p: 'p',
-                                               c: this.getColor(x,y+epStep)
+                                               c: this.getColor(x,epsq.y)
                                        });
                                        moves.push(enpassantMove);
                                }
@@ -147,13 +178,11 @@ class WildebeestRules extends ChessRules
 
        getPotentialCamelMoves(sq)
        {
-               return this.getSlideNJumpMoves(
-                       sq, VariantRules.steps[VariantRules.CAMEL], "oneStep");
+               return this.getSlideNJumpMoves(sq, V.steps[V.CAMEL], "oneStep");
        }
 
        getPotentialWildebeestMoves(sq)
        {
-               const V = VariantRules;
                return this.getSlideNJumpMoves(
                        sq, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep");
        }
@@ -168,12 +197,11 @@ class WildebeestRules extends ChessRules
        isAttackedByCamel(sq, colors)
        {
                return this.isAttackedBySlideNJump(sq, colors,
-                       VariantRules.CAMEL, VariantRules.steps[VariantRules.CAMEL], "oneStep");
+                       V.CAMEL, V.steps[V.CAMEL], "oneStep");
        }
 
        isAttackedByWildebeest(sq, colors)
        {
-               const V = VariantRules;
                return this.isAttackedBySlideNJump(sq, colors, V.WILDEBEEST,
                        V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), "oneStep");
        }
@@ -246,10 +274,11 @@ class WildebeestRules extends ChessRules
                        pieces[c][knight2Pos] = 'n';
                        pieces[c][rook2Pos] = 'r';
                }
-               let fen = pieces["b"].join("") +
+               return pieces["b"].join("") +
                        "/ppppppppppp/11/11/11/11/11/11/PPPPPPPPPPP/" +
                        pieces["w"].join("").toUpperCase() +
-                       " 1111";
-               return fen;
+                       " w 1111 -";
        }
 }
+
+const VariantRules = WildebeestRules;