Merge branch 'main' of auder.net:xogo

[xogo.git] / variants / Apocalypse / class.js

import ChessRules from "/base_rules.js";
import {ArrayFun} from "/utils/array.js";

export class ApocalypseRules extends ChessRules {

  static get Options() {
    return {};
  }

  get pawnPromotions() {
    return ['n', 'p'];
  }

  get size() {
    return {x: 5, y: 5};
  }

  setOtherVariables(fenParsed) {
    super.setOtherVariables(fenParsed);
    this.whiteMove = fenParsed.whiteMove != "-"
      ? JSON.parse(fenParsed.whiteMove)
      : null;
  }

  genRandInitBaseFen() {
    return {
      fen: "npppn/p3p/5/P3P/NPPPN w 0",
      o: {"flags":"00"}
    };
  }

  getPartFen(o) {
    let parts = super.getPartFen(o);
    parts["whiteMove"] = this.whiteMove || "-";
    return parts;
  }

  getFlagsFen() {
    return Object.values(this.penaltyFlags).join("");
  }

  setFlags(fenflags) {
    this.penaltyFlags = ArrayFun.toObject(
      ['w', 'b'], [0, 1].map(i => parseInt(fenflags.charAt(i), 10)));
  }

  getWhitemoveFen() {
    return !this.whiteMove ? "-" : JSON.stringify(this.whiteMove);
  }

  // Allow pawns to move diagonally and capture vertically,
  // because some of these moves might be valid a posteriori.
  // They will be flagged as 'illegal' in a first time, however.
  pieces(color, x, y) {
    const pawnShift = (color == "w" ? -1 : 1);
    return {
      'p': {
        "class": "pawn",
        moves: [
          {
            steps: [[pawnShift, 0], [pawnShift, -1], [pawnShift, 1]],
            range: 1
          }
        ],
      },
      'n': super.pieces(color, x, y)['n']
    };
  }

  // Allow self-captures, because they might be valid
  // if opponent takes on the same square (luck...)
  canTake() {
    return true;
  }

  getPotentialMovesFrom([x, y]) {
    let moves = [];
    if (this.subTurn == 2) {
      const start = this.moveStack[0].end;
      if (x == start.x && y == start.y) {
        // Move the pawn to any empty square not on last rank (== x)
        for (let i=0; i<this.size.x; i++) {
          if (i == x)
            continue;
          for (let j=0; j<this.size.y; j++) {
            if (this.board[i][j] == "")
              moves.push(this.getBasicMove([x, y], [i, j]));
          }
        }
      }
    }
    else {
      moves = super.getPotentialMovesFrom([x, y])
      // Flag a priori illegal moves
      moves.forEach(m => {
        if (
          // Self-capture test:
          (m.vanish.length == 2 && m.vanish[1].c == m.vanish[0].c) ||
          // Pawn going diagonaly to empty square, or vertically to occupied
          (
            m.vanish[0].p == 'p' &&
            (
              (m.end.y == m.start.y && m.vanish.length == 2) ||
              (m.end.y != m.start.y && m.vanish.length == 1)
            )
          )
        ) {
          m.illegal = true;
        }
      });
    }
    return moves;
  }

  filterValid(moves) {
    // No checks:
    return moves;
  }


//TODO: from here

  // White and black (partial) moves were played: merge
  // + animate both at the same time !
  resolveSynchroneMove(move) {
    // TODO
  }

  play(move) {
    if (this.subTurn...) //TODO: detect (mark?) if pawn move arriving on last rank (=> subTurn++)
    this.turn = V.GetOppCol(this.turn);
    this.movesCount++;
    this.postPlay(move);
  }

  postPlay(move) {
    if (pawn promotion into pawn) {
      this.curMove move; //TODO: animate both move at same time + effects AFTER !
      this.subTurn = 2
    }
    else if (this.turn == 'b')
      // NOTE: whiteMove is used read-only, so no need to copy
      this.whiteMove = move;
    }
    else {
      // A full turn just ended:
      const [wMove, bMove] = this.resolveSynchroneMove(move);
      V.PlayOnBoard(this.board, smove); //----> ici : animate both !
      this.whiteMove = null;
    }
  }

//until here


  atLeastOneLegalMove(color) {
    for (let i=0; i<this.size.x; i++) {
      for (let j=0; j<this.size.y; j++) {
        if (
          this.board[i][j] != "" &&
          this.getColor(i, j) == color &&
          this.getPotentialMoves([i, j]).some(m => !m.illegal)
        ) {
          return true;
        }
      }
    }
    return false;
  }

  getCurrentScore() {
    if (this.turn == 'b') {
      // Turn (white + black) not over yet.
      // Could be stalemate if black cannot move (legally):
      if (!this.atLeastOneLegalMove('b'))
        return "1/2";
      return "*";
    }
    // Count footmen: if a side has none, it loses
    let fmCount = { 'w': 0, 'b': 0 };
    for (let i=0; i<5; i++) {
      for (let j=0; j<5; j++) {
        if (this.board[i][j] != V.EMPTY && this.getPiece(i, j) == V.PAWN)
          fmCount[this.getColor(i, j)]++;
      }
    }
    if (Object.values(fmCount).some(v => v == 0)) {
      if (fmCount['w'] == 0 && fmCount['b'] == 0)
        // Everyone died
        return "1/2";
      if (fmCount['w'] == 0) return "0-1";
      return "1-0"; //fmCount['b'] == 0
    }
    // Check penaltyFlags: if a side has 2 or more, it loses
    if (Object.values(this.penaltyFlags).every(v => v == 2)) return "1/2";
    if (this.penaltyFlags['w'] == 2) return "0-1";
    if (this.penaltyFlags['b'] == 2) return "1-0";
    if (!this.atLeastOneLegalMove('w') || !this.atLeastOneLegalMove('b'))
      // Stalemate (should be very rare)
      return "1/2";
    return "*";
  }

};