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 bb478cc..ef3779a 100644 (file)
--- a/public/javascripts/variants/Wildebeest.js
+++ b/public/javascripts/variants/Wildebeest.js
@@ -10,16 +10,50 @@ class WildebeestRules extends ChessRules
        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) == V.PAWN && Math.abs(sx - ex) >= 2)
                {
@@ -125,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);
                                }
@@ -241,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;