Attempt to clarify installation instructions a little

[vchess.git] / client / src / variants / Alapo.js

import { ChessRules } from "@/base_rules";
import { ArrayFun } from "@/utils/array";
import { randInt } from "@/utils/alea";

export class AlapoRules extends ChessRules {

  static get HasFlags() {
    return false;
  }

  static get HasEnpassant() {
    return false;
  }

  static get Lines() {
    return [
      [[1, 0], [1, 6]],
      [[5, 0], [5, 6]]
    ];
  }

  static get PIECES() {
    return [V.ROOK, V.BISHOP, V.QUEEN, V.ROOK_S, V.BISHOP_S, V.QUEEN_S];
  }

  static get ROOK_S() {
    return "t";
  }
  static get BISHOP_S() {
    return "c";
  }
  static get QUEEN_S() {
    return "s";
  }

  getPotentialMinirookMoves(sq) {
    return super.getSlideNJumpMoves(sq, V.steps[V.ROOK], 1);
  }
  getPotentialMinibishopMoves(sq) {
    return super.getSlideNJumpMoves(sq, V.steps[V.BISHOP], 1);
  }
  getPotentialMiniqueenMoves(sq) {
    return super.getSlideNJumpMoves(
      sq, V.steps[V.ROOK].concat(V.steps[V.BISHOP]), 1);
  }

  getPotentialMovesFrom(sq) {
    switch (this.getPiece(sq[0], sq[1])) {
      case V.ROOK: return super.getPotentialRookMoves(sq);
      case V.BISHOP: return super.getPotentialBishopMoves(sq);
      case V.QUEEN: return super.getPotentialQueenMoves(sq);
      case V.ROOK_S: return this.getPotentialMinirookMoves(sq);
      case V.BISHOP_S: return this.getPotentialMinibishopMoves(sq);
      case V.QUEEN_S: return this.getPotentialMiniqueenMoves(sq);
    }
    return [];
  }

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

  getPpath(b, color, score, orientation) {
    // 'i' for "inversed":
    const suffix = (b[0] == orientation ? "" : "i");
    return "Alapo/" + b + suffix;
  }

  static GenRandInitFen(options) {
    if (options.randomness == 0)
      return "rbqqbr/tcssct/6/6/TCSSCT/RBQQBR w 0";

    const piece2pawn = {
      r: 't',
      q: 's',
      b: 'c'
    };

    let pieces = { w: new Array(6), b: new Array(6) };
    // Shuffle pieces on first (and last rank if randomness == 2)
    for (let c of ["w", "b"]) {
      if (c == 'b' && options.randomness == 1) {
        pieces['b'] = pieces['w'];
        break;
      }

      let positions = ArrayFun.range(6);

      // Get random squares for bishops
      let randIndex = 2 * randInt(3);
      const bishop1Pos = positions[randIndex];
      let randIndex_tmp = 2 * randInt(3) + 1;
      const bishop2Pos = positions[randIndex_tmp];
      positions.splice(Math.max(randIndex, randIndex_tmp), 1);
      positions.splice(Math.min(randIndex, randIndex_tmp), 1);

      // Get random square for queens
      randIndex = randInt(4);
      const queen1Pos = positions[randIndex];
      positions.splice(randIndex, 1);
      randIndex = randInt(3);
      const queen2Pos = positions[randIndex];
      positions.splice(randIndex, 1);

      // Rooks positions are now fixed,
      const rook1Pos = positions[0];
      const rook2Pos = positions[1];

      pieces[c][rook1Pos] = "r";
      pieces[c][bishop1Pos] = "b";
      pieces[c][queen1Pos] = "q";
      pieces[c][queen2Pos] = "q";
      pieces[c][bishop2Pos] = "b";
      pieces[c][rook2Pos] = "r";
    }

    return (
      pieces["b"].join("") + "/" +
      pieces["b"].map(p => piece2pawn[p]).join("") +
      "/6/6/" +
      pieces["w"].map(p => piece2pawn[p].toUpperCase()).join("") + "/" +
      pieces["w"].join("").toUpperCase() +
      " w 0"
    );
  }

  static IsGoodPosition(position) {
    if (position.length == 0) return false;
    const rows = position.split("/");
    if (rows.length != V.size.x) return false;
    // Just check that at least one piece of each color is there:
    let pieces = { "w": 0, "b": 0 };
    for (let row of rows) {
      let sumElts = 0;
      for (let i = 0; i < row.length; i++) {
        const lowerRi = row[i].toLowerCase();
        if (V.PIECES.includes(lowerRi)) {
          pieces[row[i] == lowerRi ? "b" : "w"]++;
          sumElts++;
        }
        else {
          const num = parseInt(row[i], 10);
          if (isNaN(num)) return false;
          sumElts += num;
        }
      }
      if (sumElts != V.size.y) return false;
    }
    if (Object.values(pieces).some(v => v == 0)) return false;
    return true;
  }

  // Find possible captures by opponent on [x, y]
  findCaptures([x, y]) {
    const color = this.getColor(x, y);
    let moves = [];
    const steps = V.steps[V.ROOK].concat(V.steps[V.BISHOP]);
    const oppCol = V.GetOppCol(color);
    for (let loop = 0; loop < steps.length; loop++) {
      const step = steps[loop];
      let i = x + step[0];
      let j = y + step[1];
      let stepsAfter = 1;
      while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
        i += step[0];
        j += step[1];
        stepsAfter++;
      }
      if (
        V.OnBoard(i, j) &&
        this.board[i][j] != V.EMPTY &&
        this.getColor(i, j) == oppCol
      ) {
        const oppPiece = this.getPiece(i, j);
        if (
          (
            stepsAfter >= 2 &&
            [V.ROOK_S, V.BISHOP_S, V.QUEEN_S].includes(oppPiece)
          )
          ||
          (
            [V.BISHOP, V.BISHOP_S].includes(oppPiece) &&
            step.some(e => e == 0)
          )
          ||
          (
            [V.ROOK, V.ROOK_S].includes(oppPiece) &&
            step.every(e => e != 0)
          )
        ) {
          continue;
        }
        return true;
      }
    }
    return false;
  }

  postPlay() {}
  postUndo() {}

  getCheckSquares() {
    return [];
  }
  filterValid(moves) {
    return moves;
  }

  getCurrentScore() {
    // Try both colors (to detect potential suicides)
    for (let c of ['w', 'b']) {
      const oppCol = V.GetOppCol(c);
      const goal = (c == 'w' ? 0 : 5);
      if (
        this.board[goal].some(
          (b,j) => b[0] == c && !this.findCaptures([goal, j])
        )
      ) {
        return c == 'w' ? "1-0" : "0-1";
      }
    }
    return super.getCurrentScore();
  }

  static get VALUES() {
    return {
      r: 5,
      b: 3,
      q: 9,
      t: 3,
      c: 2,
      s: 5
    };
  }

};