Adjust Chakart rules

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

import { ChessRules, Move, PiPo } from "@/base_rules";
import { randInt } from "@/utils/alea";

export class JanggiRules extends ChessRules {

  static get Monochrome() {
    return true;
  }

  static get Notoodark() {
    return true;
  }

  static get Lines() {
    let lines = [];
    // Draw all inter-squares lines, shifted:
    for (let i = 0; i < V.size.x; i++)
      lines.push([[i+0.5, 0.5], [i+0.5, V.size.y-0.5]]);
    for (let j = 0; j < V.size.y; j++)
      lines.push([[0.5, j+0.5], [V.size.x-0.5, j+0.5]]);
    // Add palaces:
    lines.push([[0.5, 3.5], [2.5, 5.5]]);
    lines.push([[0.5, 5.5], [2.5, 3.5]]);
    lines.push([[9.5, 3.5], [7.5, 5.5]]);
    lines.push([[9.5, 5.5], [7.5, 3.5]]);
    return lines;
  }

  // No castle, but flag: bikjang
  static get HasCastle() {
    return false;
  }

  static get HasEnpassant() {
    return false;
  }

  static get ELEPHANT() {
    return "e";
  }

  static get CANNON() {
    return "c";
  }

  static get ADVISOR() {
    return "a";
  }

  static get PIECES() {
    return [V.PAWN, V.ROOK, V.KNIGHT, V.ELEPHANT, V.ADVISOR, V.KING, V.CANNON];
  }

  getPpath(b) {
    return "Janggi/" + b;
  }

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

  static IsGoodFlags(flags) {
    // bikjang status of last move + pass
    return !!flags.match(/^[0-2]{2,2}$/);
  }

  aggregateFlags() {
    return [this.bikjangFlag, this.passFlag];
  }

  disaggregateFlags(flags) {
    this.bikjangFlag = flags[0];
    this.passFlag = flags[1];
  }

  getFlagsFen() {
    return this.bikjangFlag.toString() + this.passFlag.toString()
  }

  setFlags(fenflags) {
    this.bikjangFlag = parseInt(fenflags.charAt(0), 10);
    this.passFlag = parseInt(fenflags.charAt(1), 10);
  }

  setOtherVariables(fen) {
    super.setOtherVariables(fen);
    // Sub-turn is useful only at first move...
    this.subTurn = 1;
  }

  getPotentialMovesFrom([x, y]) {
    let moves = [];
    const c = this.getColor(x, y);
    const oppCol = V.GetOppCol(c);
    if (this.kingPos[c][0] == x && this.kingPos[c][1] == y) {
      // Add pass move (might be impossible if undercheck)
      moves.push(
        new Move({
          appear: [],
          vanish: [],
          start: { x: this.kingPos[c][0], y: this.kingPos[c][1] },
          end: { x: this.kingPos[oppCol][0], y: this.kingPos[oppCol][1] }
        })
      );
    }
    // TODO: next "if" is mutually exclusive with the block above
    if (this.movesCount <= 1) {
      const firstRank = (this.movesCount == 0 ? 9 : 0);
      const initDestFile = new Map([[1, 2], [7, 6]]);
      // Only option is knight --> elephant swap:
      if (
        x == firstRank &&
        !!initDestFile.get(y) &&
        this.getPiece(x, y) == V.KNIGHT
      ) {
        const destFile = initDestFile.get(y);
        moves.push(
          new Move({
            appear: [
              new PiPo({
                x: x,
                y: destFile,
                c: c,
                p: V.KNIGHT
              }),
              new PiPo({
                x: x,
                y: y,
                c: c,
                p: V.ELEPHANT
              })
            ],
            vanish: [
              new PiPo({
                x: x,
                y: y,
                c: c,
                p: V.KNIGHT
              }),
              new PiPo({
                x: x,
                y: destFile,
                c: c,
                p: V.ELEPHANT
              })
            ],
            start: { x: x, y: y },
            end: { x: x, y: destFile }
          })
        );
      }
    }
    else {
      let normalMoves = [];
      switch (this.getPiece(x, y)) {
        case V.PAWN:
          normalMoves = this.getPotentialPawnMoves([x, y]);
          break;
        case V.ROOK:
          normalMoves = this.getPotentialRookMoves([x, y]);
          break;
        case V.KNIGHT:
          normalMoves = this.getPotentialKnightMoves([x, y]);
          break;
        case V.ELEPHANT:
          normalMoves = this.getPotentialElephantMoves([x, y]);
          break;
        case V.ADVISOR:
          normalMoves = this.getPotentialAdvisorMoves([x, y]);
          break;
        case V.KING:
          normalMoves = this.getPotentialKingMoves([x, y]);
          break;
        case V.CANNON:
          normalMoves = this.getPotentialCannonMoves([x, y]);
          break;
      }
      Array.prototype.push.apply(moves, normalMoves);
    }
    return moves;
  }

  getPotentialPawnMoves([x, y]) {
    const c = this.getColor(x, y);
    const oppCol = V.GetOppCol(c);
    const shiftX = (c == 'w' ? -1 : 1);
    const rank23 = (oppCol == 'w' ? [8, 7] : [1, 2]);
    let steps = [[shiftX, 0], [0, -1], [0, 1]];
    // Diagonal moves inside enemy palace:
    if (y == 4 && x == rank23[0])
      Array.prototype.push.apply(steps, [[shiftX, 1], [shiftX, -1]]);
    else if (x == rank23[1]) {
      if (y == 3) steps.push([shiftX, 1]);
      else if (y == 5) steps.push([shiftX, -1]);
    }
    return super.getSlideNJumpMoves([x, y], steps, "oneStep");
  }

  knightStepsFromRookStep(step) {
    if (step[0] == 0) return [ [1, 2*step[1]], [-1, 2*step[1]] ];
    return [ [2*step[0], 1], [2*step[0], -1] ];
  }

  getPotentialKnightMoves([x, y]) {
    let steps = [];
    for (let rookStep of ChessRules.steps[V.ROOK]) {
      const [i, j] = [x + rookStep[0], y + rookStep[1]];
      if (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
        Array.prototype.push.apply(steps,
          // These moves might be impossible, but need to be checked:
          this.knightStepsFromRookStep(rookStep));
      }
    }
    return super.getSlideNJumpMoves([x, y], steps, "oneStep");
  }

  elephantStepsFromRookStep(step) {
    if (step[0] == 0) return [ [2, 3*step[1]], [-2, 3*step[1]] ];
    return [ [3*step[0], 2], [3*step[0], -2] ];
  }

  getPotentialElephantMoves([x, y]) {
    let steps = [];
    for (let rookStep of ChessRules.steps[V.ROOK]) {
      const eSteps = this.elephantStepsFromRookStep(rookStep);
      const [i, j] = [x + rookStep[0], y + rookStep[1]];
      if (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
        // Check second crossing:
        const knightSteps = this.knightStepsFromRookStep(rookStep);
        for (let k of [0, 1]) {
          const [ii, jj] = [x + knightSteps[k][0], y + knightSteps[k][1]];
          if (V.OnBoard(ii, jj) && this.board[ii][jj] == V.EMPTY)
            steps.push(eSteps[k]); //ok: same ordering
        }
      }
    }
    return super.getSlideNJumpMoves([x, y], steps, "oneStep");
  }

  palacePeopleMoves([x, y]) {
    const c = this.getColor(x, y);
    let steps = [];
    // Orthogonal steps:
    if (x < (c == 'w' ? 9 : 2)) steps.push([1, 0]);
    if (x > (c == 'w' ? 7 : 0)) steps.push([-1, 0]);
    if (y > 3) steps.push([0, -1]);
    if (y < 5) steps.push([0, 1]);
    // Diagonal steps, if in the middle or corner:
    if (
      y != 4 &&
      (
        (c == 'w' && x != 8) ||
        (c == 'b' && x != 1)
      )
    ) {
      // In a corner: maximum one diagonal step available
      let step = null;
      const direction = (c == 'w' ? -1 : 1);
      if ((c == 'w' && x == 9) || (c == 'b' && x == 0)) {
        // On first line
        if (y == 3) step = [direction, 1];
        else step = [direction, -1];
      }
      else if ((c == 'w' && x == 7) || (c == 'b' && x == 2)) {
        // On third line
        if (y == 3) step = [-direction, 1];
        else step = [-direction, -1];
      }
      steps.push(step);
    }
    else if (
      y == 4 &&
      (
        (c == 'w' && x == 8) ||
        (c == 'b' && x == 1)
      )
    ) {
      // At the middle: all directions available
      Array.prototype.push.apply(steps, ChessRules.steps[V.BISHOP]);
    }
    return super.getSlideNJumpMoves([x, y], steps, "oneStep");
  }

  getPotentialAdvisorMoves(sq) {
    return this.palacePeopleMoves(sq);
  }

  getPotentialKingMoves(sq) {
    return this.palacePeopleMoves(sq);
  }

  getPotentialRookMoves([x, y]) {
    let moves = super.getPotentialRookMoves([x, y]);
    if ([3, 5].includes(y) && [0, 2, 7, 9].includes(x)) {
      // In a corner of a palace: move along diagonal
      const step = [[0, 7].includes(x) ? 1 : -1, 4 - y];
      const oppCol = V.GetOppCol(this.getColor(x, y));
      for (let i of [1, 2]) {
        const [xx, yy] = [x + i * step[0], y + i * step[1]];
        if (this.board[xx][yy] == V.EMPTY)
          moves.push(this.getBasicMove([x, y], [xx, yy]));
        else {
          if (this.getColor(xx, yy) == oppCol)
            moves.push(this.getBasicMove([x, y], [xx, yy]));
          break;
        }
      }
    }
    else if (y == 4 && [1, 8].includes(x)) {
      // In the middle of a palace: 4 one-diagonal-step to check
      Array.prototype.push.apply(
        moves,
        super.getSlideNJumpMoves([x, y],
                                 ChessRules.steps[V.BISHOP],
                                 "oneStep")
      );
    }
    return moves;
  }

  // NOTE: (mostly) duplicated from Shako (TODO?)
  getPotentialCannonMoves([x, y]) {
    const oppCol = V.GetOppCol(this.turn);
    let moves = [];
    // Look in every direction until an obstacle (to jump) is met
    for (const step of V.steps[V.ROOK]) {
      let i = x + step[0];
      let j = y + step[1];
      while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
        i += step[0];
        j += step[1];
      }
      // Then, search for an enemy (if jumped piece isn't a cannon)
      if (V.OnBoard(i, j) && this.getPiece(i, j) != V.CANNON) {
        i += step[0];
        j += step[1];
        while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
          moves.push(this.getBasicMove([x, y], [i, j]));
          i += step[0];
          j += step[1];
        }
        if (
          V.OnBoard(i, j) &&
          this.getColor(i, j) == oppCol &&
          this.getPiece(i, j) != V.CANNON
        ) {
          moves.push(this.getBasicMove([x, y], [i, j]));
        }
      }
    }
    if ([3, 5].includes(y) && [0, 2, 7, 9].includes(x)) {
      // In a corner of a palace: hop over next obstacle if possible
      const step = [[0, 7].includes(x) ? 1 : -1, 4 - y];
      const [x1, y1] = [x + step[0], y + step[1]];
      const [x2, y2] = [x + 2 * step[0], y + 2 * step[1]];
      if (
        this.board[x1][y1] != V.EMPTY &&
        this.getPiece(x1, y1) != V.CANNON &&
        (
          this.board[x2][y2] == V.EMPTY ||
          (
            this.getColor(x2, y2) == oppCol &&
            this.getPiece(x2, y2) != V.CANNON
          )
        )
      ) {
        moves.push(this.getBasicMove([x, y], [x2, y2]));
      }
    }
    return moves;
  }

  // (King) Never attacked by advisor, since it stays in the palace
  isAttacked(sq, color) {
    return (
      this.isAttackedByPawn(sq, color) ||
      this.isAttackedByRook(sq, color) ||
      this.isAttackedByKnight(sq, color) ||
      this.isAttackedByElephant(sq, color) ||
      this.isAttackedByCannon(sq, color)
    );
  }

  onPalaceDiagonal([x, y]) {
    return (
      (y == 4 && [1, 8].includes(x)) ||
      ([3, 5].includes(y) && [0, 2, 7, 9].includes(x))
    );
  }

  isAttackedByPawn([x, y], color) {
    const shiftX = (color == 'w' ? 1 : -1); //shift from king
    if (super.isAttackedBySlideNJump(
      [x, y], color, V.PAWN, [[shiftX, 0], [0, 1], [0, -1]], "oneStep")
    ) {
      return true;
    }
    if (this.onPalaceDiagonal([x, y])) {
      for (let yStep of [-1, 1]) {
        const [xx, yy] = [x + shiftX, y + yStep];
        if (
          this.onPalaceDiagonal([xx,yy]) &&
          this.board[xx][yy] != V.EMPTY &&
          this.getColor(xx, yy) == color &&
          this.getPiece(xx, yy) == V.PAWN
        ) {
          return true;
        }
      }
    }
    return false;
  }

  knightStepsFromBishopStep(step) {
    return [ [2*step[0], step[1]], [step[0], 2*step[1]] ];
  }

  isAttackedByKnight([x, y], color) {
    // Check bishop steps: if empty, look continuation knight step
    let steps = [];
    for (let s of ChessRules.steps[V.BISHOP]) {
      const [i, j] = [x + s[0], y + s[1]];
      if (
        V.OnBoard(i, j) &&
        this.board[i][j] == V.EMPTY
      ) {
        Array.prototype.push.apply(steps, this.knightStepsFromBishopStep(s));
      }
    }
    return (
      super.isAttackedBySlideNJump([x, y], color, V.KNIGHT, steps, "oneStep")
    );
  }

  elephantStepsFromBishopStep(step) {
    return [ [3*step[0], 2*step[1]], [2*step[0], 3*step[1]] ];
  }

  isAttackedByElephant([x, y], color) {
    // Check bishop steps: if empty, look continuation elephant step
    let steps = [];
    for (let s of ChessRules.steps[V.BISHOP]) {
      const [i1, j1] = [x + s[0], y + s[1]];
      const [i2, j2] = [x + 2*s[0], y + 2*s[1]];
      if (
        V.OnBoard(i2, j2) && this.board[i2][j2] == V.EMPTY &&
        V.OnBoard(i1, j1) && this.board[i1][j1] == V.EMPTY
      ) {
        Array.prototype.push.apply(steps, this.elephantStepsFromBishopStep(s));
      }
    }
    return (
      super.isAttackedBySlideNJump([x, y], color, V.ELEPHANT, steps, "oneStep")
    );
  }

  isAttackedByRook([x, y], color) {
    if (super.isAttackedByRook([x, y], color)) return true;
    // Also check diagonals, if inside palace
    if (this.onPalaceDiagonal([x, y])) {
      // TODO: next scan is clearly suboptimal
      for (let s of ChessRules.steps[V.BISHOP]) {
        for (let i of [1, 2]) {
          const [xx, yy] = [x + i * s[0], y + i * s[1]];
          if (
            V.OnBoard(xx, yy) &&
            this.onPalaceDiagonal([xx, yy])
          ) {
            if (this.board[xx][yy] != V.EMPTY) {
              if (
                this.getColor(xx, yy) == color &&
                this.getPiece(xx, yy) == V.ROOK
              ) {
                return true;
              }
              break;
            }
          }
          else continue;
        }
      }
    }
    return false;
  }

  // NOTE: (mostly) duplicated from Shako (TODO?)
  isAttackedByCannon([x, y], color) {
    // Reversed process: is there an obstacle in line,
    // and a cannon next in the same line?
    for (const step of V.steps[V.ROOK]) {
      let [i, j] = [x+step[0], y+step[1]];
      while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
        i += step[0];
        j += step[1];
      }
      if (V.OnBoard(i, j) && this.getPiece(i, j) != V.CANNON) {
        // Keep looking in this direction
        i += step[0];
        j += step[1];
        while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
          i += step[0];
          j += step[1];
        }
        if (
          V.OnBoard(i, j) &&
          this.getPiece(i, j) == V.CANNON &&
          this.getColor(i, j) == color
        ) {
          return true;
        }
      }
    }
    return false;
  }

  getCurrentScore() {
    if ([this.bikjangFlag, this.passFlag].includes(2)) return "1/2";
    const color = this.turn;
    // super.atLeastOneMove() does not consider passing (OK)
    if (this.underCheck(color) && !super.atLeastOneMove())
      return (color == "w" ? "0-1" : "1-0");
    return "*";
  }

  static get VALUES() {
    return {
      p: 2,
      r: 13,
      n: 5,
      e: 3,
      a: 3,
      c: 7,
      k: 1000
    };
  }

  static get SEARCH_DEPTH() {
    return 2;
  }

  static GenRandInitFen() {
    // No randomization here (but initial setup choice)
    return (
      "rnea1aenr/4k4/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/4K4/RNEA1AENR w 0 00"
    );
  }

  play(move) {
    move.subTurn = this.subTurn; //much easier
    if (this.movesCount >= 2 || this.subTurn == 2 || move.vanish.length == 0) {
      this.turn = V.GetOppCol(this.turn);
      this.subTurn = 1;
      this.movesCount++;
    }
    else this.subTurn = 2;
    move.flags = JSON.stringify(this.aggregateFlags());
    V.PlayOnBoard(this.board, move);
    this.postPlay(move);
  }

  postPlay(move) {
    if (move.vanish.length > 0) super.postPlay(move);
    else if (this.movesCount > 2) this.passFlag++;
    // Update bikjang flag
    if (this.kingPos['w'][1] == this.kingPos['b'][1]) {
      const y = this.kingPos['w'][1];
      let bikjang = true;
      for (let x = this.kingPos['b'][0] + 1; x < this.kingPos['w'][0]; x++) {
        if (this.board[x][y] != V.EMPTY) {
          bikjang = false;
          break;
        }
      }
      if (bikjang) this.bikjangFlag++;
      else this.bikjangFlag = 0;
    }
    else this.bikjangFlag = 0;
  }

  undo(move) {
    this.disaggregateFlags(JSON.parse(move.flags));
    V.UndoOnBoard(this.board, move);
    this.postUndo(move);
    if (this.movesCount >= 2 || this.subTurn == 1 || move.vanish.length == 0) {
      this.turn = V.GetOppCol(this.turn);
      this.movesCount--;
    }
    this.subTurn = move.subTurn;
  }

  postUndo(move) {
    if (move.vanish.length > 0) super.postUndo(move);
  }

  getComputerMove() {
    if (this.movesCount <= 1) {
      // Special case: swap and pass at random
      const moves1 = this.getAllValidMoves();
      const m1 = moves1[randInt(moves1.length)];
      this.play(m1);
      if (m1.vanish.length == 0) {
        this.undo(m1);
        return m1;
      }
      const moves2 = this.getAllValidMoves();
      const m2 = moves2[randInt(moves2.length)];
      this.undo(m1);
      return [m1, m2];
    }
    return super.getComputerMove();
  }

  getNotation(move) {
    if (move.vanish.length == 0) return "pass";
    if (move.appear.length == 2) return "S"; //"swap"
    let notation = super.getNotation(move);
    if (move.vanish.length == 2 && move.vanish[0].p == V.PAWN)
      notation = "P" + notation.substr(1);
    return notation;
  }

};