Reorganize folders (untested Baroque). Draft Go

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

import ChessRules from "/base_rules.js";
import GiveawayRules from "/variants/Giveaway/class.js";
import AbstractSpecialCaptureRules from "/variants/_SpecialCaptures.js";
import {Random} from "/utils/alea.js";
import PiPo from "/utils/PiPo.js";
import Move from "/utils/Move.js";

export default class BaroqueRules extends AbstractSpecialCaptureRules {

  static get Options() {
    return {
      select: C.Options.Select,
      input: [
        {
          label: "Capture king",
          variable: "taking",
          type: "checkbox",
          defaut: false
        }
      ],
      styles: [
        "balance",
        "capture",
        "crazyhouse",
        "cylinder",
        "doublemove",
        "progressive",
        "recycle",
        "teleport"
      ]
    };
  }

  get hasFlags() {
    return false;
  }

  genRandInitBaseFen() {
    if (this.options["randomness"] == 0)
      return "rnbkqbnm/pppppppp/8/8/8/8/PPPPPPPP/MNBQKBNR";
    const options = Object.assign({mode: "suicide"}, this.options);
    const gr = new GiveawayRules({options: options, genFenOnly: true});
    let res = gr.genRandInitBaseFen();
    let immPos = {};
    for (let c of ['w', 'b']) {
      const rookChar = (c == 'w' ? 'R' : 'r');
      switch (Random.randInt(2)) {
        case 0:
          immPos[c] = res.fen.indexOf(rookChar);
          break;
        case 1:
          immPos[c] = res.fen.lastIndexOf(rookChar);
          break;
      }
    }
    res.fen = res.fen.substring(0, immPos['b']) + 'i' +
              res.fen.substring(immPos['b'] + 1, immPos['w']) + 'I' +
              res.fen.substring(immPos['w'] + 1);
    return res;
  }

  pieces() {
    return Object.assign({},
      super.pieces(),
      {
        'p': {
          "class": "pawn", //pincer
          moves: [
            {steps: [[0, 1], [0, -1], [1, 0], [-1, 0]]}
          ]
        },
        'r': {
          "class": "rook", //coordinator
          moves: [
            {
              steps: [
                [1, 0], [0, 1], [-1, 0], [0, -1],
                [1, 1], [1, -1], [-1, 1], [-1, -1]
              ]
            }
          ]
        },
        'n': {
          "class": "knight", //long-leaper
          moveas: 'r'
        },
        'b': {
          "class": "bishop", //chameleon
          moveas: 'r'
        },
        'q': {
          "class": "queen", //withdrawer
          moveas: 'r'
        },
        'i': {
          "class": "immobilizer",
          moveas: 'r'
        }
      }
    );
  }

  // Is piece on square (x,y) immobilized?
  isImmobilized([x, y]) {
    const piece = this.getPiece(x, y);
    const color = this.getColor(x, y);
    const oppCol = C.GetOppCol(color);
    const adjacentSteps = this.pieces()['k'].moves[0].steps;
    for (let step of adjacentSteps) {
      const [i, j] = [x + step[0], this.getY(y + step[1])];
      if (
        this.onBoard(i, j) &&
        this.board[i][j] != "" &&
        this.getColor(i, j) == oppCol
      ) {
        const oppPiece = this.getPiece(i, j);
        if (oppPiece == 'i') {
          // Moving is possible only if this immobilizer is neutralized
          for (let step2 of adjacentSteps) {
            const [i2, j2] = [i + step2[0], this.getY(j + step2[1])];
            if (i2 == x && j2 == y)
              continue; //skip initial piece!
            if (
              this.onBoard(i2, j2) &&
              this.board[i2][j2] != "" &&
              this.getColor(i2, j2) == color
            ) {
              if (['b', 'i'].includes(this.getPiece(i2, j2)))
                return false;
            }
          }
          return true; //immobilizer isn't neutralized
        }
        // Chameleons can't be immobilized twice,
        // because there is only one immobilizer
        if (oppPiece == 'b' && piece == 'i')
          return true;
      }
    }
    return false;
  }

  canTake([x1, y1], [x2, y2]) {
    // Deactivate standard captures, except for king:
    return (
      this.getPiece(x1, y1) == 'k' &&
      this.getColor(x1, y1) != this.getColor(x2, y2)
    );
  }

  postProcessPotentialMoves(moves) {
    if (moves.length == 0)
      return [];
    switch (moves[0].vanish[0].p) {
      case 'p':
        this.addPincerCaptures(moves);
        break;
      case 'r':
        this.addCoordinatorCaptures(moves);
        break;
      case 'n':
        const [x, y] = [moves[0].start.x, moves[0].start.y];
        moves = moves.concat(this.getLeaperCaptures([x, y]));
        break;
      case 'b':
        moves = this.getChameleonCaptures(moves, "pull");
        break;
      case 'q':
        this.addPushmePullyouCaptures(moves, false, "pull");
        break;
    }
    return moves;
  }

};