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

import { ChessRules } from "@/base_rules";

export class CwdaRules extends ChessRules {

  static get Options() {
    return {
      select: ChessRules.Options.select.concat([
        {
          label: "Army 1",
          variable: "army1",
          defaut: 'C',
          options: [
            { label: "Colorbound Clobberers", value: 'C' },
            { label: "Nutty Knights", value: 'N' },
            { label: "Remarkable Rookies", value: 'R' },
            { label: "Fide", value: 'F' }
          ]
        },
        {
          label: "Army 2",
          variable: "army2",
          defaut: 'C',
          options: [
            { label: "Colorbound Clobberers", value: 'C' },
            { label: "Nutty Knights", value: 'N' },
            { label: "Remarkable Rookies", value: 'R' },
            { label: "Fide", value: 'F' }
          ]
        }
      ])
    };
  }

  static AbbreviateOptions(opts) {
    return opts["army1"] + opts["army2"];
  }

  static IsValidOptions(opts) {
    // Both armies filled, avoid Fide vs Fide
    return (
      opts.army1 && opts.army2 &&
      (opts.army1 != 'F' || opts.army2 != 'F')
    );
  }

  getPpath(b) {
    return (ChessRules.PIECES.includes(b[1]) ? "" : "Cwda/") + b;
  }

  static get PiecesMap() {
    return {
      // Colorbound Clobberers
      'C': {
        'r': 'd',
        'n': 'w',
        'b': 'f',
        'q': 'c',
        'k': 'k',
        'p': 'p'
      },
      // Nutty Knights
      'N': {
        'r': 'g',
        'n': 'i',
        'b': 't',
        'q': 'l',
        'k': 'k', //TODO: e
        'p': 'p' //TODO: v
      },
      // Remarkable Rookies
      'R': {
        'r': 's',
        'n': 'y',
        'b': 'h',
        'q': 'o',
        'k': 'a',
        'p': 'u'
      }
    };
  }

  static GenRandInitFen(options) {
    const baseFen = ChessRules.GenRandInitFen(options.randomness);
    let blackLine = baseFen.substr(0, 8), blackPawns = "pppppppp";
    if (options.army2 != 'F') {
      blackLine = blackLine.split('')
        .map(p => V.PiecesMap[options.army2][p]).join('');
      blackPawns = V.PiecesMap[options.army2]['p'].repeat(8);
    }
    let whiteLine = baseFen.substr(35, 8), whitePawns = "PPPPPPPP";
    if (options.army1 != 'F') {
      whiteLine = whiteLine.split('')
        .map(p => V.PiecesMap[options.army1][p.toLowerCase()])
        .join('').toUpperCase();
      whitePawns = V.PiecesMap[options.army1]['p'].toUpperCase().repeat(8);
    }
    return (
      blackLine + "/" + blackPawns +
      baseFen.substring(17, 26) +
      whitePawns + "/" + whiteLine +
      baseFen.substr(43) + " " + options.army1 + options.army2
    );
  }

  setOtherVariables(fen) {
    super.setOtherVariables(fen);
    const armies = V.ParseFen(fen).armies;
    this.army1 = armies.charAt(0);
    this.army2 = armies.charAt(1);
  }

  static ParseFen(fen) {
    return Object.assign(
      { armies: fen.split(" ")[5] },
      ChessRules.ParseFen(fen)
    );
  }

  static IsGoodFen(fen) {
    if (!ChessRules.IsGoodFen(fen)) return false;
    const armies = V.ParseFen(fen).armies;
    return (!!armies && armies.match(/^[CNRF]{2,2}$/));
  }

  getFen() {
    return super.getFen() + " " + this.army1 + this.army2;
  }

  static get C_ROOK() {
    return 'd';
  }
  static get C_KNIGHT() {
    return 'w';
  }
  static get C_BISHOP() {
    return 'f';
  }
  static get C_QUEEN() {
    return 'c';
  }
  static get N_ROOK() {
    return 'g';
  }
  static get N_KNIGHT() {
    return 'i';
  }
  static get N_BISHOP() {
    return 't';
  }
  static get N_QUEEN() {
    return 'l';
  }
  static get N_KING() {
    return 'e';
  }
  static get N_PAWN() {
    return 'v';
  }
  static get R_ROOK() {
    return 's';
  }
  static get R_KNIGHT() {
    return 'y';
  }
  static get R_BISHOP() {
    return 'h';
  }
  static get R_QUEEN() {
    return 'o';
  }
  static get R_KING() {
    return 'a';
  }
  static get R_PAWN() {
    return 'u';
  }

  getPiece(x, y) {
    const p = this.board[x][y][1];
    if (['u', 'v'].includes(p)) return 'p';
    if (['a', 'e'].includes(p)) return 'k';
    return p;
  }

  static get PIECES() {
    return ChessRules.PIECES.concat(
      [
        V.C_ROOK, V.C_KNIGHT, V.C_BISHOP, V.C_QUEEN,
        V.N_ROOK, V.N_KNIGHT, V.N_BISHOP, V.N_QUEEN, V.N_KING, V.N_PAWN,
        V.R_ROOK, V.R_KNIGHT, V.R_BISHOP, V.R_QUEEN, V.R_KING, V.R_PAWN
      ]
    );
  }

  getPotentialMovesFrom(sq) {
    switch (this.getPiece(sq[0], sq[1])) {
      case V.C_ROOK: return this.getPotentialC_rookMoves(sq);
      case V.C_KNIGHT: return this.getPotentialC_knightMoves(sq);
      case V.C_BISHOP: return this.getPotentialC_bishopMoves(sq);
      case V.C_QUEEN: return this.getPotentialC_queenMoves(sq);
      case V.N_ROOK: return this.getPotentialN_rookMoves(sq);
      case V.N_KNIGHT: return this.getPotentialN_knightMoves(sq);
      case V.N_BISHOP: return this.getPotentialN_bishopMoves(sq);
      case V.N_QUEEN: return this.getPotentialN_queenMoves(sq);
      case V.R_ROOK: return this.getPotentialR_rookMoves(sq);
      case V.R_KNIGHT: return this.getPotentialR_knightMoves(sq);
      case V.R_BISHOP: return this.getPotentialR_bishopMoves(sq);
      case V.R_QUEEN: return this.getPotentialR_queenMoves(sq);
      case V.PAWN: {
        // Can promote in anything from the two current armies
        let promotions = [];
        for (let army of ["army1", "army2"]) {
          if (army == "army2" && this.army2 == this.army1) break;
          switch (this[army]) {
            case 'C': {
              Array.prototype.push.apply(promotions,
                [V.C_ROOK, V.C_KNIGHT, V.C_BISHOP, V.C_QUEEN]);
              break;
            }
            case 'N': {
              Array.prototype.push.apply(promotions,
                [V.N_ROOK, V.N_KNIGHT, V.N_BISHOP, V.N_QUEEN]);
              break;
            }
            case 'R': {
              Array.prototype.push.apply(promotions,
                [V.R_ROOK, V.R_KNIGHT, V.R_BISHOP, V.R_QUEEN]);
              break;
            }
            case 'F': {
              Array.prototype.push.apply(promotions,
                [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]);
              break;
            }
          }
        }
        return super.getPotentialPawnMoves(sq, promotions);
      }
      default: return super.getPotentialMovesFrom(sq);
    }
    return [];
  }

  static get steps() {
    return Object.assign(
      {
        // Dabbabah
        'd': [
          [-2, 0],
          [0, -2],
          [2, 0],
          [0, 2]
        ],
        // Alfil
        'a': [
          [2, 2],
          [2, -2],
          [-2, 2],
          [-2, -2]
        ],
        // Ferz
        'f': [
          [1, 1],
          [1, -1],
          [-1, 1],
          [-1, -1]
        ],
        // Wazir
        'w': [
          [-1, 0],
          [0, -1],
          [1, 0],
          [0, 1]
        ],
        // Threeleaper
        '$3': [
          [-3, 0],
          [0, -3],
          [3, 0],
          [0, 3]
        ],
        // Narrow knight
        '$n': [
          [-2, -1],
          [-2, 1],
          [2, -1],
          [2, 1]
        ]
      },
      ChessRules.steps,
    );
  }

  getPotentialC_rookMoves(sq) {
    return (
      this.getSlideNJumpMoves(sq, V.steps.b).concat(
      this.getSlideNJumpMoves(sq, V.steps.d, 1))
    );
  }

  getPotentialC_knightMoves(sq) {
    return (
      this.getSlideNJumpMoves(sq, V.steps.a, 1).concat(
      this.getSlideNJumpMoves(sq, V.steps.r, 1))
    );
  }

  getPotentialC_bishopMoves(sq) {
    return (
      this.getSlideNJumpMoves(sq, V.steps.d, 1).concat(
      this.getSlideNJumpMoves(sq, V.steps.a, 1)).concat(
      this.getSlideNJumpMoves(sq, V.steps.b, 1))
    );
  }

  getPotentialC_queenMoves(sq) {
    return (
      this.getSlideNJumpMoves(sq, V.steps.b).concat(
        this.getSlideNJumpMoves(sq, V.steps.n, 1))
    );
  }

  getPotentialN_rookMoves(sq) {
    const c = this.turn;
    const rookSteps = [ [0, -1], [0, 1], [c == 'w' ? -1 : 1, 0] ];
    const backward = (c == 'w' ? 1 : -1);
    const kingSteps = [ [backward, -1], [backward, 0], [backward, 1] ];
    return (
      this.getSlideNJumpMoves(sq, rookSteps).concat(
      this.getSlideNJumpMoves(sq, kingSteps, 1))
    );
  }

  getPotentialN_knightMoves(sq) {
    return (
      this.getSlideNJumpMoves(sq, V.steps.$n, 1).concat(
      this.getSlideNJumpMoves(sq, V.steps.f, 1))
    );
  }

  getPotentialN_bishopMoves(sq) {
    const backward = (this.turn == 'w' ? 1 : -1);
    const kingSteps = [
      [0, -1], [0, 1], [backward, -1], [backward, 0], [backward, 1]
    ];
    const forward = -backward;
    const knightSteps = [
      [2*forward, -1], [2*forward, 1], [forward, -2], [forward, 2]
    ];
    return (
      this.getSlideNJumpMoves(sq, knightSteps, 1).concat(
      this.getSlideNJumpMoves(sq, kingSteps, 1))
    );
  }

  getPotentialN_queenMoves(sq) {
    const backward = (this.turn == 'w' ? 1 : -1);
    const forward = -backward;
    const kingSteps = [
      [forward, -1], [forward, 1],
      [backward, -1], [backward, 0], [backward, 1]
    ];
    const knightSteps = [
      [2*forward, -1], [2*forward, 1], [forward, -2], [forward, 2]
    ];
    const rookSteps = [ [0, -1], [0, 1], [forward, 0] ];
    return (
      this.getSlideNJumpMoves(sq, rookSteps).concat(
      this.getSlideNJumpMoves(sq, kingSteps, 1)).concat(
      this.getSlideNJumpMoves(sq, knightSteps, 1))
    );
  }

  getPotentialR_rookMoves(sq) {
    return this.getSlideNJumpMoves(sq, V.steps.r, 4);
  }

  getPotentialR_knightMoves(sq) {
    return (
      this.getSlideNJumpMoves(sq, V.steps.d, 1).concat(
      this.getSlideNJumpMoves(sq, V.steps.w, 1))
    );
  }

  getPotentialR_bishopMoves(sq) {
    return (
      this.getSlideNJumpMoves(sq, V.steps.d, 1).concat(
      this.getSlideNJumpMoves(sq, V.steps.f, 1)).concat(
      this.getSlideNJumpMoves(sq, V.steps.$3, 1))
    );
  }

  getPotentialR_queenMoves(sq) {
    return (
      this.getSlideNJumpMoves(sq, V.steps.r).concat(
      this.getSlideNJumpMoves(sq, V.steps.n, 1))
    );
  }

  getCastleMoves([x, y]) {
    const color = this.getColor(x, y);
    let finalSquares = [ [2, 3], [V.size.y - 2, V.size.y - 3] ];
    if (
      (color == 'w' && this.army1 == 'C') ||
      (color == 'b' && this.army2 == 'C')
    ) {
      // Colorbound castle long in an unusual way:
      finalSquares[0] = [1, 2];
    }
    return super.getCastleMoves([x, y], finalSquares);
  }

  isAttacked(sq, color) {
    if (super.isAttackedByPawn(sq, color) || super.isAttackedByKing(sq, color))
      return true;
    for (let army of ['C', 'N', 'R', 'F']) {
      if (
        [this.army1, this.army2].includes(army) &&
        (
          this["isAttackedBy" + army + "_rook"](sq, color) ||
          this["isAttackedBy" + army + "_knight"](sq, color) ||
          this["isAttackedBy" + army + "_bishop"](sq, color) ||
          this["isAttackedBy" + army + "_queen"](sq, color)
        )
      ) {
        return true;
      }
    }
    return false;
  }

  isAttackedByC_rook(sq, color) {
    return (
      this.isAttackedBySlideNJump(sq, color, V.C_ROOK, V.steps.b) ||
      this.isAttackedBySlideNJump(sq, color, V.C_ROOK, V.steps.d, 1)
    );
  }

  isAttackedByC_knight(sq, color) {
    return (
      this.isAttackedBySlideNJump(sq, color, V.C_KNIGHT, V.steps.r, 1) ||
      this.isAttackedBySlideNJump(sq, color, V.C_KNIGHT, V.steps.a, 1)
    );
  }

  isAttackedByC_bishop(sq, color) {
    return (
      this.isAttackedBySlideNJump(sq, color, V.C_BISHOP, V.steps.d, 1) ||
      this.isAttackedBySlideNJump(sq, color, V.C_BISHOP, V.steps.a, 1) ||
      this.isAttackedBySlideNJump(sq, color, V.C_BISHOP, V.steps.f, 1)
    );
  }

  isAttackedByC_queen(sq, color) {
    return (
      this.isAttackedBySlideNJump(sq, color, V.C_QUEEN, V.steps.b) ||
      this.isAttackedBySlideNJump(sq, color, V.C_QUEEN, V.steps.n, 1)
    );
  }

  isAttackedByN_rook(sq, color) {
    const rookSteps = [ [0, -1], [0, 1], [color == 'w' ? 1 : -1, 0] ];
    const backward = (color == 'w' ? -1 : 1);
    const kingSteps = [ [backward, -1], [backward, 0], [backward, 1] ];
    return (
      this.isAttackedBySlideNJump(sq, color, V.N_ROOK, rookSteps) ||
      this.isAttackedBySlideNJump(sq, color, V.N_ROOK, kingSteps, 1)
    );
  }

  isAttackedByN_knight(sq, color) {
    return (
      this.isAttackedBySlideNJump(sq, color, V.N_KNIGHT, V.steps.$n, 1) ||
      this.isAttackedBySlideNJump(sq, color, V.N_KNIGHT, V.steps.f, 1)
    );
  }

  isAttackedByN_bishop(sq, color) {
    const backward = (color == 'w' ? -1 : 1);
    const kingSteps = [
      [0, -1], [0, 1], [backward, -1], [backward, 0], [backward, 1]
    ];
    const forward = -backward;
    const knightSteps = [
      [2*forward, -1], [2*forward, 1], [forward, -2], [forward, 2]
    ];
    return (
      this.isAttackedBySlideNJump(sq, color, V.N_BISHOP, knightSteps, 1) ||
      this.isAttackedBySlideNJump(sq, color, V.N_BISHOP, kingSteps, 1)
    );
  }

  isAttackedByN_queen(sq, color) {
    const backward = (color == 'w' ? -1 : 1);
    const forward = -backward;
    const kingSteps = [
      [forward, -1], [forward, 1],
      [backward, -1], [backward, 0], [backward, 1]
    ];
    const knightSteps = [
      [2*forward, -1], [2*forward, 1], [forward, -2], [forward, 2]
    ];
    const rookSteps = [ [0, -1], [0, 1], [forward, 0] ];
    return (
      this.isAttackedBySlideNJump(sq, color, V.N_QUEEN, knightSteps, 1) ||
      this.isAttackedBySlideNJump(sq, color, V.N_QUEEN, kingSteps, 1) ||
      this.isAttackedBySlideNJump(sq, color, V.N_QUEEN, rookSteps)
    );
  }

  isAttackedByR_rook(sq, color) {
    return this.isAttackedBySlideNJump(sq, color, V.R_ROOK, V.steps.r, 4);
  }

  isAttackedByR_knight(sq, color) {
    return (
      this.isAttackedBySlideNJump(sq, color, V.R_KNIGHT, V.steps.d, 1) ||
      this.isAttackedBySlideNJump(sq, color, V.R_KNIGHT, V.steps.w, 1)
    );
  }

  isAttackedByR_bishop(sq, color) {
    return (
      this.isAttackedBySlideNJump(sq, color, V.R_BISHOP, V.steps.d, 1) ||
      this.isAttackedBySlideNJump(sq, color, V.R_BISHOP, V.steps.f, 1) ||
      this.isAttackedBySlideNJump(sq, color, V.R_BISHOP, V.steps.$3, 1)
    );
  }

  isAttackedByR_queen(sq, color) {
    return (
      this.isAttackedBySlideNJump(sq, color, V.R_QUEEN, V.steps.r) ||
      this.isAttackedBySlideNJump(sq, color, V.R_QUEEN, V.steps.n, 1)
    );
  }

  // [HACK] So that the function above works also on Fide army:
  isAttackedByF_rook(sq, color) {
    return super.isAttackedByRook(sq, color);
  }
  isAttackedByF_knight(sq, color) {
    return super.isAttackedByKnight(sq, color);
  }
  isAttackedByF_bishop(sq, color) {
    return super.isAttackedByBishop(sq, color);
  }
  isAttackedByF_queen(sq, color) {
    return super.isAttackedByQueen(sq, color);
  }

  static get VALUES() {
    return Object.assign(
      {
        d: 4,
        w: 3,
        f: 5,
        c: 7,
        g: 4,
        i: 3,
        t: 4,
        l: 7,
        s: 4,
        y: 3,
        h: 4,
        o: 8
      },
      ChessRules.VALUES
    );
  }

  static get SEARCH_DEPTH() {
    return 2;
  }

};
Commit	Line	Data
4313762d	1	import { ChessRules } from "@/base_rules";
801e2870	2
cee75a57	3	export class CwdaRules extends ChessRules {
7e8a7ea1	4
4313762d BA	5	static get Options() {
	6	return {
	7	select: ChessRules.Options.select.concat([
	8	{
	9	label: "Army 1",
	10	variable: "army1",
	11	defaut: 'C',
	12	options: [
	13	{ label: "Colorbound Clobberers", value: 'C' },
	14	{ label: "Nutty Knights", value: 'N' },
	15	{ label: "Remarkable Rookies", value: 'R' },
	16	{ label: "Fide", value: 'F' }
	17	]
	18	},
	19	{
	20	label: "Army 2",
	21	variable: "army2",
	22	defaut: 'C',
	23	options: [
	24	{ label: "Colorbound Clobberers", value: 'C' },
	25	{ label: "Nutty Knights", value: 'N' },
	26	{ label: "Remarkable Rookies", value: 'R' },
	27	{ label: "Fide", value: 'F' }
	28	]
	29	}
	30	])
	31	};
	32	}
	33
	34	static AbbreviateOptions(opts) {
	35	return opts["army1"] + opts["army2"];
	36	}
	37
	38	static IsValidOptions(opts) {
	39	// Both armies filled, avoid Fide vs Fide
	40	return (
	41	opts.army1 && opts.army2 &&
	42	(opts.army1 != 'F' \|\| opts.army2 != 'F')
801e2870 BA	43	);
	44	}
	45
	46	getPpath(b) {
4313762d BA	47	return (ChessRules.PIECES.includes(b[1]) ? "" : "Cwda/") + b;
	48	}
	49
	50	static get PiecesMap() {
	51	return {
	52	// Colorbound Clobberers
	53	'C': {
	54	'r': 'd',
	55	'n': 'w',
	56	'b': 'f',
	57	'q': 'c',
74afb57d BA	58	'k': 'k',
74afb57d BA	59	'p': 'p'
4313762d BA	60	},
	61	// Nutty Knights
	62	'N': {
	63	'r': 'g',
	64	'n': 'i',
	65	'b': 't',
	66	'q': 'l',
74afb57d BA	67	'k': 'k', //TODO: e
74afb57d BA	68	'p': 'p' //TODO: v
4313762d BA	69	},
	70	// Remarkable Rookies
	71	'R': {
	72	'r': 's',
	73	'n': 'y',
	74	'b': 'h',
	75	'q': 'o',
74afb57d BA	76	'k': 'a',
74afb57d BA	77	'p': 'u'
4313762d	78	}
801e2870	79	};
4313762d	80	}
801e2870	81
4313762d BA	82	static GenRandInitFen(options) {
4313762d BA	83	const baseFen = ChessRules.GenRandInitFen(options.randomness);
74afb57d	84	let blackLine = baseFen.substr(0, 8), blackPawns = "pppppppp";
4313762d BA	85	if (options.army2 != 'F') {
	86	blackLine = blackLine.split('')
	87	.map(p => V.PiecesMap[options.army2][p]).join('');
74afb57d	88	blackPawns = V.PiecesMap[options.army2]['p'].repeat(8);
4313762d	89	}
74afb57d	90	let whiteLine = baseFen.substr(35, 8), whitePawns = "PPPPPPPP";
4313762d BA	91	if (options.army1 != 'F') {
	92	whiteLine = whiteLine.split('')
	93	.map(p => V.PiecesMap[options.army1][p.toLowerCase()])
	94	.join('').toUpperCase();
74afb57d	95	whitePawns = V.PiecesMap[options.army1]['p'].toUpperCase().repeat(8);
4313762d	96	}
801e2870	97	return (
74afb57d BA	98	blackLine + "/" + blackPawns +
	99	baseFen.substring(17, 26) +
	100	whitePawns + "/" + whiteLine +
4313762d	101	baseFen.substr(43) + " " + options.army1 + options.army2
801e2870 BA	102	);
	103	}
	104
4313762d BA	105	setOtherVariables(fen) {
	106	super.setOtherVariables(fen);
	107	const armies = V.ParseFen(fen).armies;
	108	this.army1 = armies.charAt(0);
	109	this.army2 = armies.charAt(1);
	110	}
	111
	112	static ParseFen(fen) {
	113	return Object.assign(
	114	{ armies: fen.split(" ")[5] },
	115	ChessRules.ParseFen(fen)
	116	);
	117	}
	118
	119	static IsGoodFen(fen) {
	120	if (!ChessRules.IsGoodFen(fen)) return false;
	121	const armies = V.ParseFen(fen).armies;
10cceb25	122	return (!!armies && armies.match(/^[CNRF]{2,2}$/));
4313762d BA	123	}
	124
	125	getFen() {
	126	return super.getFen() + " " + this.army1 + this.army2;
	127	}
	128
801e2870 BA	129	static get C_ROOK() {
	130	return 'd';
	131	}
	132	static get C_KNIGHT() {
4313762d	133	return 'w';
801e2870 BA	134	}
801e2870 BA	135	static get C_BISHOP() {
4313762d	136	return 'f';
801e2870 BA	137	}
801e2870 BA	138	static get C_QUEEN() {
4313762d BA	139	return 'c';
	140	}
	141	static get N_ROOK() {
	142	return 'g';
	143	}
	144	static get N_KNIGHT() {
	145	return 'i';
	146	}
	147	static get N_BISHOP() {
	148	return 't';
	149	}
	150	static get N_QUEEN() {
	151	return 'l';
	152	}
74afb57d BA	153	static get N_KING() {
	154	return 'e';
	155	}
	156	static get N_PAWN() {
	157	return 'v';
	158	}
4313762d	159	static get R_ROOK() {
801e2870 BA	160	return 's';
801e2870 BA	161	}
4313762d BA	162	static get R_KNIGHT() {
	163	return 'y';
	164	}
	165	static get R_BISHOP() {
	166	return 'h';
	167	}
	168	static get R_QUEEN() {
	169	return 'o';
	170	}
74afb57d BA	171	static get R_KING() {
	172	return 'a';
	173	}
	174	static get R_PAWN() {
	175	return 'u';
	176	}
	177
	178	getPiece(x, y) {
	179	const p = this.board[x][y][1];
	180	if (['u', 'v'].includes(p)) return 'p';
	181	if (['a', 'e'].includes(p)) return 'k';
	182	return p;
	183	}
801e2870 BA	184
801e2870 BA	185	static get PIECES() {
4313762d	186	return ChessRules.PIECES.concat(
74afb57d BA	187	[
	188	V.C_ROOK, V.C_KNIGHT, V.C_BISHOP, V.C_QUEEN,
	189	V.N_ROOK, V.N_KNIGHT, V.N_BISHOP, V.N_QUEEN, V.N_KING, V.N_PAWN,
	190	V.R_ROOK, V.R_KNIGHT, V.R_BISHOP, V.R_QUEEN, V.R_KING, V.R_PAWN
	191	]
	192	);
801e2870 BA	193	}
801e2870 BA	194
4313762d BA	195	getPotentialMovesFrom(sq) {
	196	switch (this.getPiece(sq[0], sq[1])) {
	197	case V.C_ROOK: return this.getPotentialC_rookMoves(sq);
	198	case V.C_KNIGHT: return this.getPotentialC_knightMoves(sq);
	199	case V.C_BISHOP: return this.getPotentialC_bishopMoves(sq);
	200	case V.C_QUEEN: return this.getPotentialC_queenMoves(sq);
	201	case V.N_ROOK: return this.getPotentialN_rookMoves(sq);
	202	case V.N_KNIGHT: return this.getPotentialN_knightMoves(sq);
	203	case V.N_BISHOP: return this.getPotentialN_bishopMoves(sq);
	204	case V.N_QUEEN: return this.getPotentialN_queenMoves(sq);
	205	case V.R_ROOK: return this.getPotentialR_rookMoves(sq);
	206	case V.R_KNIGHT: return this.getPotentialR_knightMoves(sq);
	207	case V.R_BISHOP: return this.getPotentialR_bishopMoves(sq);
	208	case V.R_QUEEN: return this.getPotentialR_queenMoves(sq);
	209	case V.PAWN: {
	210	// Can promote in anything from the two current armies
	211	let promotions = [];
	212	for (let army of ["army1", "army2"]) {
	213	if (army == "army2" && this.army2 == this.army1) break;
	214	switch (this[army]) {
	215	case 'C': {
	216	Array.prototype.push.apply(promotions,
	217	[V.C_ROOK, V.C_KNIGHT, V.C_BISHOP, V.C_QUEEN]);
	218	break;
	219	}
	220	case 'N': {
	221	Array.prototype.push.apply(promotions,
	222	[V.N_ROOK, V.N_KNIGHT, V.N_BISHOP, V.N_QUEEN]);
	223	break;
	224	}
	225	case 'R': {
	226	Array.prototype.push.apply(promotions,
	227	[V.R_ROOK, V.R_KNIGHT, V.R_BISHOP, V.R_QUEEN]);
	228	break;
	229	}
	230	case 'F': {
	231	Array.prototype.push.apply(promotions,
	232	[V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]);
	233	break;
	234	}
	235	}
	236	}
	237	return super.getPotentialPawnMoves(sq, promotions);
	238	}
	239	default: return super.getPotentialMovesFrom(sq);
801e2870 BA	240	}
	241	return [];
	242	}
	243
	244	static get steps() {
	245	return Object.assign(
801e2870 BA	246	{
	247	// Dabbabah
	248	'd': [
	249	[-2, 0],
	250	[0, -2],
	251	[2, 0],
	252	[0, 2]
	253	],
	254	// Alfil
	255	'a': [
	256	[2, 2],
	257	[2, -2],
	258	[-2, 2],
	259	[-2, -2]
	260	],
	261	// Ferz
	262	'f': [
	263	[1, 1],
	264	[1, -1],
	265	[-1, 1],
	266	[-1, -1]
4313762d BA	267	],
	268	// Wazir
	269	'w': [
	270	[-1, 0],
	271	[0, -1],
	272	[1, 0],
	273	[0, 1]
	274	],
	275	// Threeleaper
	276	'$3': [
	277	[-3, 0],
	278	[0, -3],
	279	[3, 0],
	280	[0, 3]
	281	],
	282	// Narrow knight
	283	'$n': [
	284	[-2, -1],
	285	[-2, 1],
	286	[2, -1],
	287	[2, 1]
801e2870	288	]
4313762d BA	289	},
4313762d BA	290	ChessRules.steps,
801e2870 BA	291	);
	292	}
	293
	294	getPotentialC_rookMoves(sq) {
	295	return (
4313762d BA	296	this.getSlideNJumpMoves(sq, V.steps.b).concat(
4313762d BA	297	this.getSlideNJumpMoves(sq, V.steps.d, 1))
801e2870 BA	298	);
	299	}
	300
	301	getPotentialC_knightMoves(sq) {
	302	return (
4313762d BA	303	this.getSlideNJumpMoves(sq, V.steps.a, 1).concat(
4313762d BA	304	this.getSlideNJumpMoves(sq, V.steps.r, 1))
801e2870 BA	305	);
	306	}
	307
	308	getPotentialC_bishopMoves(sq) {
	309	return (
4313762d BA	310	this.getSlideNJumpMoves(sq, V.steps.d, 1).concat(
	311	this.getSlideNJumpMoves(sq, V.steps.a, 1)).concat(
	312	this.getSlideNJumpMoves(sq, V.steps.b, 1))
801e2870 BA	313	);
	314	}
	315
	316	getPotentialC_queenMoves(sq) {
	317	return (
4313762d BA	318	this.getSlideNJumpMoves(sq, V.steps.b).concat(
	319	this.getSlideNJumpMoves(sq, V.steps.n, 1))
	320	);
	321	}
	322
	323	getPotentialN_rookMoves(sq) {
	324	const c = this.turn;
	325	const rookSteps = [ [0, -1], [0, 1], [c == 'w' ? -1 : 1, 0] ];
	326	const backward = (c == 'w' ? 1 : -1);
	327	const kingSteps = [ [backward, -1], [backward, 0], [backward, 1] ];
	328	return (
	329	this.getSlideNJumpMoves(sq, rookSteps).concat(
	330	this.getSlideNJumpMoves(sq, kingSteps, 1))
	331	);
	332	}
	333
	334	getPotentialN_knightMoves(sq) {
4313762d BA	335	return (
4313762d BA	336	this.getSlideNJumpMoves(sq, V.steps.$n, 1).concat(
902378e6	337	this.getSlideNJumpMoves(sq, V.steps.f, 1))
4313762d BA	338	);
	339	}
	340
	341	getPotentialN_bishopMoves(sq) {
	342	const backward = (this.turn == 'w' ? 1 : -1);
	343	const kingSteps = [
	344	[0, -1], [0, 1], [backward, -1], [backward, 0], [backward, 1]
	345	];
	346	const forward = -backward;
	347	const knightSteps = [
	348	[2forward, -1], [2forward, 1], [forward, -2], [forward, 2]
	349	];
	350	return (
	351	this.getSlideNJumpMoves(sq, knightSteps, 1).concat(
	352	this.getSlideNJumpMoves(sq, kingSteps, 1))
	353	);
	354	}
	355
	356	getPotentialN_queenMoves(sq) {
	357	const backward = (this.turn == 'w' ? 1 : -1);
	358	const forward = -backward;
	359	const kingSteps = [
	360	[forward, -1], [forward, 1],
	361	[backward, -1], [backward, 0], [backward, 1]
	362	];
	363	const knightSteps = [
	364	[2forward, -1], [2forward, 1], [forward, -2], [forward, 2]
	365	];
	366	const rookSteps = [ [0, -1], [0, 1], [forward, 0] ];
	367	return (
	368	this.getSlideNJumpMoves(sq, rookSteps).concat(
	369	this.getSlideNJumpMoves(sq, kingSteps, 1)).concat(
	370	this.getSlideNJumpMoves(sq, knightSteps, 1))
	371	);
	372	}
	373
	374	getPotentialR_rookMoves(sq) {
	375	return this.getSlideNJumpMoves(sq, V.steps.r, 4);
	376	}
	377
	378	getPotentialR_knightMoves(sq) {
	379	return (
	380	this.getSlideNJumpMoves(sq, V.steps.d, 1).concat(
	381	this.getSlideNJumpMoves(sq, V.steps.w, 1))
	382	);
	383	}
	384
	385	getPotentialR_bishopMoves(sq) {
	386	return (
	387	this.getSlideNJumpMoves(sq, V.steps.d, 1).concat(
	388	this.getSlideNJumpMoves(sq, V.steps.f, 1)).concat(
	389	this.getSlideNJumpMoves(sq, V.steps.$3, 1))
	390	);
	391	}
	392
	393	getPotentialR_queenMoves(sq) {
	394	return (
	395	this.getSlideNJumpMoves(sq, V.steps.r).concat(
	396	this.getSlideNJumpMoves(sq, V.steps.n, 1))
801e2870 BA	397	);
	398	}
	399
801e2870	400	getCastleMoves([x, y]) {
7e8a7ea1	401	const color = this.getColor(x, y);
4313762d BA	402	let finalSquares = [ [2, 3], [V.size.y - 2, V.size.y - 3] ];
	403	if (
	404	(color == 'w' && this.army1 == 'C') \|\|
	405	(color == 'b' && this.army2 == 'C')
	406	) {
	407	// Colorbound castle long in an unusual way:
	408	finalSquares[0] = [1, 2];
	409	}
7e8a7ea1	410	return super.getCastleMoves([x, y], finalSquares);
801e2870 BA	411	}
	412
	413	isAttacked(sq, color) {
4313762d BA	414	if (super.isAttackedByPawn(sq, color) \|\| super.isAttackedByKing(sq, color))
	415	return true;
	416	for (let army of ['C', 'N', 'R', 'F']) {
	417	if (
	418	[this.army1, this.army2].includes(army) &&
	419	(
	420	this["isAttackedBy" + army + "_rook"](sq, color) \|\|
	421	this["isAttackedBy" + army + "_knight"](sq, color) \|\|
	422	this["isAttackedBy" + army + "_bishop"](sq, color) \|\|
	423	this["isAttackedBy" + army + "_queen"](sq, color)
	424	)
	425	) {
	426	return true;
	427	}
	428	}
	429	return false;
801e2870 BA	430	}
	431
	432	isAttackedByC_rook(sq, color) {
	433	return (
4313762d BA	434	this.isAttackedBySlideNJump(sq, color, V.C_ROOK, V.steps.b) \|\|
4313762d BA	435	this.isAttackedBySlideNJump(sq, color, V.C_ROOK, V.steps.d, 1)
801e2870 BA	436	);
	437	}
	438
	439	isAttackedByC_knight(sq, color) {
	440	return (
4313762d BA	441	this.isAttackedBySlideNJump(sq, color, V.C_KNIGHT, V.steps.r, 1) \|\|
4313762d BA	442	this.isAttackedBySlideNJump(sq, color, V.C_KNIGHT, V.steps.a, 1)
801e2870 BA	443	);
	444	}
	445
	446	isAttackedByC_bishop(sq, color) {
	447	return (
4313762d BA	448	this.isAttackedBySlideNJump(sq, color, V.C_BISHOP, V.steps.d, 1) \|\|
	449	this.isAttackedBySlideNJump(sq, color, V.C_BISHOP, V.steps.a, 1) \|\|
	450	this.isAttackedBySlideNJump(sq, color, V.C_BISHOP, V.steps.f, 1)
801e2870 BA	451	);
	452	}
	453
	454	isAttackedByC_queen(sq, color) {
	455	return (
4313762d BA	456	this.isAttackedBySlideNJump(sq, color, V.C_QUEEN, V.steps.b) \|\|
	457	this.isAttackedBySlideNJump(sq, color, V.C_QUEEN, V.steps.n, 1)
	458	);
	459	}
	460
	461	isAttackedByN_rook(sq, color) {
	462	const rookSteps = [ [0, -1], [0, 1], [color == 'w' ? 1 : -1, 0] ];
	463	const backward = (color == 'w' ? -1 : 1);
	464	const kingSteps = [ [backward, -1], [backward, 0], [backward, 1] ];
	465	return (
	466	this.isAttackedBySlideNJump(sq, color, V.N_ROOK, rookSteps) \|\|
	467	this.isAttackedBySlideNJump(sq, color, V.N_ROOK, kingSteps, 1)
	468	);
	469	}
	470
	471	isAttackedByN_knight(sq, color) {
4313762d	472	return (
902378e6 BA	473	this.isAttackedBySlideNJump(sq, color, V.N_KNIGHT, V.steps.$n, 1) \|\|
902378e6 BA	474	this.isAttackedBySlideNJump(sq, color, V.N_KNIGHT, V.steps.f, 1)
4313762d BA	475	);
	476	}
	477
	478	isAttackedByN_bishop(sq, color) {
	479	const backward = (color == 'w' ? -1 : 1);
	480	const kingSteps = [
	481	[0, -1], [0, 1], [backward, -1], [backward, 0], [backward, 1]
	482	];
	483	const forward = -backward;
	484	const knightSteps = [
	485	[2forward, -1], [2forward, 1], [forward, -2], [forward, 2]
	486	];
	487	return (
	488	this.isAttackedBySlideNJump(sq, color, V.N_BISHOP, knightSteps, 1) \|\|
	489	this.isAttackedBySlideNJump(sq, color, V.N_BISHOP, kingSteps, 1)
	490	);
	491	}
	492
	493	isAttackedByN_queen(sq, color) {
	494	const backward = (color == 'w' ? -1 : 1);
	495	const forward = -backward;
	496	const kingSteps = [
	497	[forward, -1], [forward, 1],
	498	[backward, -1], [backward, 0], [backward, 1]
	499	];
	500	const knightSteps = [
	501	[2forward, -1], [2forward, 1], [forward, -2], [forward, 2]
	502	];
	503	const rookSteps = [ [0, -1], [0, 1], [forward, 0] ];
	504	return (
	505	this.isAttackedBySlideNJump(sq, color, V.N_QUEEN, knightSteps, 1) \|\|
	506	this.isAttackedBySlideNJump(sq, color, V.N_QUEEN, kingSteps, 1) \|\|
	507	this.isAttackedBySlideNJump(sq, color, V.N_QUEEN, rookSteps)
	508	);
	509	}
	510
	511	isAttackedByR_rook(sq, color) {
	512	return this.isAttackedBySlideNJump(sq, color, V.R_ROOK, V.steps.r, 4);
	513	}
	514
	515	isAttackedByR_knight(sq, color) {
	516	return (
	517	this.isAttackedBySlideNJump(sq, color, V.R_KNIGHT, V.steps.d, 1) \|\|
	518	this.isAttackedBySlideNJump(sq, color, V.R_KNIGHT, V.steps.w, 1)
	519	);
	520	}
	521
	522	isAttackedByR_bishop(sq, color) {
	523	return (
	524	this.isAttackedBySlideNJump(sq, color, V.R_BISHOP, V.steps.d, 1) \|\|
	525	this.isAttackedBySlideNJump(sq, color, V.R_BISHOP, V.steps.f, 1) \|\|
	526	this.isAttackedBySlideNJump(sq, color, V.R_BISHOP, V.steps.$3, 1)
	527	);
	528	}
	529
	530	isAttackedByR_queen(sq, color) {
	531	return (
	532	this.isAttackedBySlideNJump(sq, color, V.R_QUEEN, V.steps.r) \|\|
	533	this.isAttackedBySlideNJump(sq, color, V.R_QUEEN, V.steps.n, 1)
801e2870 BA	534	);
	535	}
	536
b2f43cc3 BA	537	// [HACK] So that the function above works also on Fide army:
	538	isAttackedByF_rook(sq, color) {
	539	return super.isAttackedByRook(sq, color);
	540	}
	541	isAttackedByF_knight(sq, color) {
	542	return super.isAttackedByKnight(sq, color);
	543	}
	544	isAttackedByF_bishop(sq, color) {
	545	return super.isAttackedByBishop(sq, color);
	546	}
	547	isAttackedByF_queen(sq, color) {
	548	return super.isAttackedByQueen(sq, color);
	549	}
	550
801e2870 BA	551	static get VALUES() {
801e2870 BA	552	return Object.assign(
801e2870 BA	553	{
801e2870 BA	554	d: 4,
4313762d BA	555	w: 3,
	556	f: 5,
	557	c: 7,
	558	g: 4,
	559	i: 3,
	560	t: 4,
	561	l: 7,
	562	s: 4,
	563	y: 3,
	564	h: 4,
	565	o: 8
	566	},
	567	ChessRules.VALUES
801e2870 BA	568	);
801e2870 BA	569	}
48252022 BA	570
	571	static get SEARCH_DEPTH() {
	572	return 2;
	573	}
7e8a7ea1	574
801e2870	575	};