X-Git-Url: https://git.auder.net/?a=blobdiff_plain;f=client%2Fsrc%2Fbase_rules.js;h=ef07742cf6ebbc3588c8b75684bd96ae07db4752;hb=c322a84434326dff1291a57e82dbd995817a5423;hp=5ebe4997741d88d2fb70f8db8825c103618b8505;hpb=20620465247585ed4e845885c4d9fee8cd6920c1;p=vchess.git diff --git a/client/src/base_rules.js b/client/src/base_rules.js index 5ebe4997..ef07742c 100644 --- a/client/src/base_rules.js +++ b/client/src/base_rules.js @@ -43,19 +43,29 @@ export const ChessRules = class ChessRules { } // Some variants cannot have analyse mode - static get CanAnalyse() { + static get CanAnalyze() { return true; } + // Patch: issues with javascript OOP, objects can't access static fields. + get canAnalyze() { + return V.CanAnalyze; + } // Some variants show incomplete information, // and thus show only a partial moves list or no list at all. static get ShowMoves() { return "all"; } + get showMoves() { + return V.ShowMoves; + } - // Path to pieces - static getPpath(b) { - return b; //usual pieces in pieces/ folder + // Some variants always show the same orientation + static get CanFlip() { + return true; + } + get canFlip() { + return V.CanFlip; } // Turn "wb" into "B" (for FEN) @@ -96,9 +106,12 @@ export const ChessRules = class ChessRules { if (position.length == 0) return false; const rows = position.split("/"); if (rows.length != V.size.x) return false; + let kings = {}; 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]] = true; if (V.PIECES.includes(row[i].toLowerCase())) sumElts++; else { const num = parseInt(row[i]); @@ -108,6 +121,9 @@ export const ChessRules = class ChessRules { } if (sumElts != V.size.y) return false; } + // Both kings should be on board: + if (Object.keys(kings).length != 2) + return false; return true; } @@ -154,6 +170,11 @@ export const ChessRules = class ChessRules { return V.CoordToColumn(coords.y) + (V.size.x - coords.x); } + // Path to pieces + getPpath(b) { + return b; //usual pieces in pieces/ folder + } + // Aggregates flags into one object aggregateFlags() { return this.castleFlags; @@ -261,12 +282,13 @@ export const ChessRules = class ChessRules { pieces[c][knight2Pos] = "n"; pieces[c][rook2Pos] = "r"; } + // Add turn + flags + enpassant return ( pieces["b"].join("") + "/pppppppp/8/8/8/8/PPPPPPPP/" + pieces["w"].join("").toUpperCase() + " w 0 1111 -" - ); //add turn + flags + enpassant + ); } // "Parse" FEN: just return untransformed string data @@ -351,9 +373,9 @@ export const ChessRules = class ChessRules { for (let indexInRow = 0; indexInRow < rows[i].length; indexInRow++) { const character = rows[i][indexInRow]; const num = parseInt(character); + // If num is a number, just shift j: if (!isNaN(num)) j += num; - //just shift j - //something at position i,j + // Else: something at position i,j else board[i][j++] = V.fen2board(character); } } @@ -364,7 +386,6 @@ export const ChessRules = class ChessRules { setFlags(fenflags) { // white a-castle, h-castle, black a-castle, h-castle this.castleFlags = { w: [true, true], b: [true, true] }; - if (!fenflags) return; for (let i = 0; i < 4; i++) this.castleFlags[i < 2 ? "w" : "b"][i % 2] = fenflags.charAt(i) == "1"; } @@ -373,7 +394,9 @@ export const ChessRules = class ChessRules { // INITIALIZATION constructor(fen) { - this.re_init(fen); + // In printDiagram() fen isn't supply because only getPpath() is used + if (fen) + this.re_init(fen); } // Fen string fully describes the game state @@ -429,7 +452,7 @@ export const ChessRules = class ChessRules { if (V.HasEnpassant) { const epSq = parsedFen.enpassant != "-" - ? V.SquareToCoords(parsedFen.enpassant) + ? this.getEpSquare(parsedFen.enpassant) : undefined; this.epSquares = [epSq]; } @@ -444,7 +467,7 @@ export const ChessRules = class ChessRules { return { x: 8, y: 8 }; } - // Color of thing on suqare (i,j). 'undefined' if square is empty + // Color of thing on square (i,j). 'undefined' if square is empty getColor(i, j) { return this.board[i][j].charAt(0); } @@ -520,7 +543,7 @@ export const ChessRules = class ChessRules { //////////////////// // MOVES GENERATION - // All possible moves from selected square (assumption: color is OK) + // All possible moves from selected square getPotentialMovesFrom([x, y]) { switch (this.getPiece(x, y)) { case V.PAWN: @@ -611,8 +634,8 @@ export const ChessRules = class ChessRules { x + shiftX == lastRank ? [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN] : [V.PAWN]; - // One square forward if (this.board[x + shiftX][y] == V.EMPTY) { + // One square forward for (let piece of finalPieces) { moves.push( this.getBasicMove([x, y], [x + shiftX, y], { @@ -716,10 +739,11 @@ export const ChessRules = class ChessRules { const oppCol = V.GetOppCol(c); let moves = []; let i = 0; + // King, then rook: const finalSquares = [ [2, 3], [V.size.y - 2, V.size.y - 3] - ]; //king, then rook + ]; castlingCheck: for ( let castleSide = 0; castleSide < 2; @@ -961,6 +985,8 @@ export const ChessRules = class ChessRules { // After move is played, update variables + flags updateVariables(move) { let piece = undefined; + // TODO: update variables before move is played, and just use this.turn ? + // (doesn't work in general, think MarseilleChess) let c = undefined; if (move.vanish.length >= 1) { // Usual case, something is moved @@ -971,9 +997,8 @@ export const ChessRules = class ChessRules { piece = move.appear[0].p; c = move.appear[0].c; } - if (c == "c") { - //if (!["w","b"].includes(c)) - // 'c = move.vanish[0].c' doesn't work for Checkered + if (!['w','b'].includes(c)) { + // Checkered, for example c = V.GetOppCol(this.turn); } const firstRank = c == "w" ? V.size.x - 1 : 0; @@ -1016,9 +1041,9 @@ export const ChessRules = class ChessRules { play(move) { // DEBUG: - // if (!this.states) this.states = []; - // const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen(); - // this.states.push(stateFen); +// if (!this.states) this.states = []; +// const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen(); +// this.states.push(stateFen); if (V.HasFlags) move.flags = JSON.stringify(this.aggregateFlags()); //save flags (for undo) if (V.HasEnpassant) this.epSquares.push(this.getEpSquare(move)); @@ -1037,9 +1062,9 @@ export const ChessRules = class ChessRules { this.unupdateVariables(move); // DEBUG: - // const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen(); - // if (stateFen != this.states[this.states.length-1]) debugger; - // this.states.pop(); +// const stateFen = this.getBaseFen() + this.getTurnFen() + this.getFlagsFen(); +// if (stateFen != this.states[this.states.length-1]) debugger; +// this.states.pop(); } /////////////// @@ -1048,7 +1073,6 @@ export const ChessRules = class ChessRules { // What is the score ? (Interesting if game is over) getCurrentScore() { if (this.atLeastOneMove()) - // game not over return "*"; // Game over @@ -1097,6 +1121,7 @@ export const ChessRules = class ChessRules { // Some variants may show a bigger moves list to the human (Switching), // thus the argument "computer" below (which is generally ignored) let moves1 = this.getAllValidMoves("computer"); + if (moves1.length == 0) //TODO: this situation should not happen return null; @@ -1185,7 +1210,7 @@ export const ChessRules = class ChessRules { return (color == "w" ? 1 : -1) * (b.eval - a.eval); }); } else return currentBest; - // console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; })); + console.log(moves1.map(m => { return [this.getNotation(m), m.eval]; })); candidates = [0]; for (let j = 1; j < moves1.length && moves1[j].eval == moves1[0].eval; j++) @@ -1230,6 +1255,18 @@ export const ChessRules = class ChessRules { for (let j = 0; j < V.size.y; j++) { if (this.board[i][j] != V.EMPTY) { const sign = this.getColor(i, j) == "w" ? 1 : -1; + + +//TODO: debug in KnightRelay +if (isNaN(V.VALUES[this.getPiece(i, j)])) { + console.log(i + " " + j); + console.log(this.getPiece(i, j)); + console.log(this.board); + console.log("ajout " + sign + " * "+ V.VALUES[this.getPiece(i, j)]); + debugger; +} + + evaluation += sign * V.VALUES[this.getPiece(i, j)]; } } @@ -1245,7 +1282,7 @@ export const ChessRules = class ChessRules { // TODO: un-ambiguous notation (switch on piece type, check directions...) getNotation(move) { if (move.appear.length == 2 && move.appear[0].p == V.KING) - //castle + // Castle return move.end.y < move.start.y ? "0-0-0" : "0-0"; // Translate final square @@ -1259,10 +1296,10 @@ export const ChessRules = class ChessRules { // Capture const startColumn = V.CoordToColumn(move.start.y); notation = startColumn + "x" + finalSquare; - } //no capture + } else notation = finalSquare; if (move.appear.length > 0 && move.appear[0].p != V.PAWN) - //promotion + // Promotion notation += "=" + move.appear[0].p.toUpperCase(); return notation; }