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

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

export class PacosakoRules extends ChessRules {

  static get IMAGE_EXTENSION() {
    return ".png";
  }

  // Unions (left = white if upperCase, black otherwise)
  static get UNIONS() {
    return {
      a: ['p', 'p'],
      c: ['p', 'r'],
      d: ['p', 'n'],
      e: ['p', 'b'],
      f: ['p', 'q'],
      g: ['p', 'k'],
      h: ['r', 'r'],
      i: ['r', 'n'],
      j: ['r', 'b'],
      l: ['r', 'q'],
      m: ['r', 'k'],
      o: ['n', 'n'],
      s: ['n', 'b'],
      t: ['n', 'q'],
      u: ['n', 'k'],
      v: ['b', 'b'],
      w: ['b', 'q'],
      x: ['b', 'k'],
      y: ['q', 'q'],
      z: ['q', 'k']
    };
  }

  static IsGoodPosition(position) {
    if (position.length == 0) return false;
    const rows = position.split("/");
    if (rows.length != V.size.x) return false;
    let kingSymb = ['k', 'g', 'm', 'u', 'x'];
    let kings = { 'k': 0, 'K': 0 };
    for (let row of rows) {
      let sumElts = 0;
      for (let i = 0; i < row.length; i++) {
        const lowR = row[i].toLowerCase
        if (!!(row[i].toLowerCase().match(/[a-z]/))) {
          sumElts++;
          if (kingSymb.includes(row[i])) kings['k']++;
          else if (kingSymb.some(s => row[i] == s.toUpperCase())) kings['K']++;
        }
        else {
          const num = parseInt(row[i], 10);
          if (isNaN(num) || num <= 0) return false;
          sumElts += num;
        }
      }
      if (sumElts != V.size.y) return false;
    }
    // Both kings should be on board. Exactly one per color.
    if (Object.values(kings).some(v => v != 1)) return false;
    return true;
  }

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

  getPPpath(m) {
    if (ChessRules.PIECES.includes(m.appear[0].p)) return super.getPPpath(m);
    // For an union, show only relevant piece:
    // The color must be deduced from the move: reaching final rank of who?
    const color = (m.appear[0].x == 0 ? 'w' : 'b');
    const up = this.getUnionPieces(m.appear[0].c, m.appear[0].p);
    return "Pacosako/" + color + up[color];
  }

  canTake([x1, y1], [x2, y2]) {
    const p1 = this.board[x1][y1].charAt(1);
    if (!(ChessRules.PIECES.includes(p1))) return false;
    const p2 = this.board[x2][y2].charAt(1);
    if (!(ChessRules.PIECES.includes(p2))) return true;
    const c1 = this.board[x1][y1].charAt(0);
    const c2 = this.board[x2][y2].charAt(0);
    return (c1 != c2);
  }

  canIplay(side, [x, y]) {
    return (
      this.turn == side &&
      (
        !(ChessRules.PIECES.includes(this.board[x][y].charAt(1))) ||
        this.board[x][y].charAt(0) == side
      )
    );
  }

  scanKings(fen) {
    this.kingPos = { w: [-1, -1], b: [-1, -1] };
    const fenRows = V.ParseFen(fen).position.split("/");
    const startRow = { 'w': V.size.x - 1, 'b': 0 };
    const kingSymb = ['k', 'g', 'm', 'u', 'x'];
    for (let i = 0; i < fenRows.length; i++) {
      let k = 0;
      for (let j = 0; j < fenRows[i].length; j++) {
        const c = fenRows[i].charAt(j);
        if (kingSymb.includes(c))
          this.kingPos["b"] = [i, k];
        else if (kingSymb.some(s => c == s.toUpperCase()))
          this.kingPos["w"] = [i, k];
        else {
          const num = parseInt(fenRows[i].charAt(j), 10);
          if (!isNaN(num)) k += num - 1;
        }
        k++;
      }
    }
  }

  setOtherVariables(fen) {
    super.setOtherVariables(fen);
    // Stack of "last move" only for intermediate chaining
    this.lastMoveEnd = [null];
    // Local stack of non-capturing union moves:
    this.umoves = [];
    const umove = V.ParseFen(fen).umove;
    if (umove == "-") this.umoves.push(null);
    else {
      this.umoves.push({
        start: ChessRules.SquareToCoords(umove.substr(0, 2)),
        end: ChessRules.SquareToCoords(umove.substr(2))
      });
    }
  }

  static IsGoodFen(fen) {
    if (!ChessRules.IsGoodFen(fen)) return false;
    const fenParts = fen.split(" ");
    if (fenParts.length != 6) return false;
    if (fenParts[5] != "-" && !fenParts[5].match(/^([a-h][1-8]){2}$/))
      return false;
    return true;
  }

  getUmove(move) {
    if (
      move.vanish.length == 1 &&
      !(ChessRules.PIECES.includes(move.appear[0].p))
    ) {
      // An union moving
      return { start: move.start, end: move.end };
    }
    return null;
  }

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

  static GenRandInitFen(randomness) {
    // Add empty umove
    return ChessRules.GenRandInitFen(randomness) + " -";
  }

  getUmoveFen() {
    const L = this.umoves.length;
    return (
      !this.umoves[L - 1]
        ? "-"
        : ChessRules.CoordsToSquare(this.umoves[L - 1].start) +
          ChessRules.CoordsToSquare(this.umoves[L - 1].end)
    );
  }

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

  getFenForRepeat() {
    return super.getFenForRepeat() + "_" + this.getUmoveFen();
  }

  getColor(i, j) {
    const p = this.board[i][j].charAt(1);
    if (ChessRules.PIECES.includes(p)) return super.getColor(i, j);
    return this.turn; //union: I can use it, so it's "my" color...
  }

  getPiece(i, j, color) {
    const p = this.board[i][j].charAt(1);
    if (ChessRules.PIECES.includes(p)) return p;
    const c = this.board[i][j].charAt(0);
    // NOTE: this.turn == HACK, but should work...
    color = color || this.turn;
    return V.UNIONS[p][c == color ? 0 : 1];
  }

  getUnionPieces(color, code) {
    const pieces = V.UNIONS[code];
    return {
      w: pieces[color == 'w' ? 0 : 1],
      b: pieces[color == 'b' ? 0 : 1]
    };
  }

  // p1: white piece, p2: black piece
  getUnionCode(p1, p2) {
    let uIdx = (
      Object.values(V.UNIONS).findIndex(v => v[0] == p1 && v[1] == p2)
    );
    const c = (uIdx >= 0 ? 'w' : 'b');
    if (uIdx == -1) {
      uIdx = (
        Object.values(V.UNIONS).findIndex(v => v[0] == p2 && v[1] == p1)
      );
    }
    return { c: c, p: Object.keys(V.UNIONS)[uIdx] };
  }

  getBasicMove([sx, sy], [ex, ey], tr) {
    const L = this.lastMoveEnd.length;
    const lm = this.lastMoveEnd[L-1];
    const piece = (!!lm ? lm.p : null);
    const initColor = (!!piece ? this.turn : this.board[sx][sy].charAt(0));
    const initPiece = (piece || this.board[sx][sy].charAt(1));
    const c = this.turn;
    const oppCol = V.GetOppCol(c);
    if (!!tr && !(ChessRules.PIECES.includes(initPiece))) {
      // Transformation computed without taking union into account
      const up = this.getUnionPieces(initColor, initPiece);
      let args = [tr.p, up[oppCol]];
      if (c == 'b') args = args.reverse();
      const cp = this.getUnionCode(args[0], args[1]);
      tr.c = cp.c;
      tr.p = cp.p;
    }
    // 4 cases : moving
    //  - union to free square (other cases are illegal: return null)
    //  - normal piece to free square,
    //                 to enemy normal piece, or
    //                 to union (releasing our piece)
    let mv = new Move({
      start: { x: sx, y: sy },
      end: { x: ex, y: ey },
      vanish: []
    });
    if (!piece) {
      mv.vanish = [
        new PiPo({
          x: sx,
          y: sy,
          c: initColor,
          p: initPiece
        })
      ];
    }
    // Treat free square cases first:
    if (this.board[ex][ey] == V.EMPTY) {
      mv.appear = [
        new PiPo({
          x: ex,
          y: ey,
          c: !!tr ? tr.c : initColor,
          p: !!tr ? tr.p : initPiece
        })
      ];
      return mv;
    }
    // Now the two cases with union / release:
    const destColor = this.board[ex][ey].charAt(0);
    const destPiece = this.board[ex][ey].charAt(1);
    mv.vanish.push(
      new PiPo({
        x: ex,
        y: ey,
        c: destColor,
        p: destPiece
      })
    );
    if (ChessRules.PIECES.includes(destPiece)) {
      // Normal piece: just create union
      let args = [!!tr ? tr.p : initPiece, destPiece];
      if (c == 'b') args = args.reverse();
      const cp = this.getUnionCode(args[0], args[1]);
      mv.appear = [
        new PiPo({
          x: ex,
          y: ey,
          c: cp.c,
          p: cp.p
        })
      ];
      return mv;
    }
    // Releasing a piece in an union: keep track of released piece
    const up = this.getUnionPieces(destColor, destPiece);
    let args = [!!tr ? tr.p : initPiece, up[oppCol]];
    if (c == 'b') args = args.reverse();
    const cp = this.getUnionCode(args[0], args[1]);
    mv.appear = [
      new PiPo({
        x: ex,
        y: ey,
        c: cp.c,
        p: cp.p
      })
    ];
    mv.released = up[c];
    return mv;
  }

  getPotentialMovesFrom([x, y]) {
    const L = this.lastMoveEnd.length;
    const lm = this.lastMoveEnd[L-1];
    if (!!lm && (x != lm.x || y != lm.y)) return [];
    const piece = (!!lm ? lm.p : this.getPiece(x, y));
    if (!!lm) {
      var saveSquare = this.board[x][y];
      this.board[x][y] = this.turn + piece;
    }
    let baseMoves = [];
    switch (piece || this.getPiece(x, y)) {
      case V.PAWN:
        baseMoves = this.getPotentialPawnMoves([x, y]);
        break;
      case V.ROOK:
        baseMoves = this.getPotentialRookMoves([x, y]);
        break;
      case V.KNIGHT:
        baseMoves = this.getPotentialKnightMoves([x, y]);
        break;
      case V.BISHOP:
        baseMoves = this.getPotentialBishopMoves([x, y]);
        break;
      case V.QUEEN:
        baseMoves = this.getPotentialQueenMoves([x, y]);
        break;
      case V.KING:
        baseMoves = this.getPotentialKingMoves([x, y]);
        break;
    }
    // When a pawn in an union reaches final rank with a non-standard
    // promotion move: apply promotion anyway
    let moves = [];
    const c = this.turn;
    const oppCol = V.GetOppCol(c);
    const oppLastRank = (c == 'w' ? 7 : 0);
    baseMoves.forEach(m => {
      if (
        m.end.x == oppLastRank &&
        ['c', 'd', 'e', 'f', 'g'].includes(m.appear[0].p)
      ) {
        // Move to first rank, which is last rank for opponent's pawn.
        // => Show promotion choices.
        // Find our piece in union (not a pawn)
        const up = this.getUnionPieces(m.appear[0].c, m.appear[0].p);
        // merge with all potential promotion pieces + push (loop)
        for (let promotionPiece of [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]) {
          let args = [up[c], promotionPiece];
          if (c == 'b') args = args.reverse();
          const cp = this.getUnionCode(args[0], args[1]);
          let cpMove = JSON.parse(JSON.stringify(m));
          cpMove.appear[0].c = cp.c;
          cpMove.appear[0].p = cp.p;
          moves.push(cpMove);
        }
      }
      else {
        if (
          m.vanish.length > 0 &&
          m.vanish[0].p == V.PAWN &&
          m.start.y != m.end.y &&
          this.board[m.end.x][m.end.y] == V.EMPTY
        ) {
          if (!!lm)
            // No en-passant inside a chaining
            return;
          // Fix en-passant capture: union type, maybe released piece too
          const cs = [m.end.x + (c == 'w' ? 1 : -1), m.end.y];
          const color = this.board[cs[0]][cs[1]].charAt(0);
          const code = this.board[cs[0]][cs[1]].charAt(1);
          if (code == V.PAWN) {
            // Simple en-passant capture (usual: just form union)
            m.appear[0].c = 'w';
            m.appear[0].p = 'a';
          }
          else {
            // An union pawn + something juste moved two squares
            const up = this.getUnionPieces(color, code);
            m.released = up[c];
            let args = [V.PAWN, up[oppCol]];
            if (c == 'b') args = args.reverse();
            const cp = this.getUnionCode(args[0], args[1]);
            m.appear[0].c = cp.c;
            m.appear[0].p = cp.p;
          }
        }
        moves.push(m);
      }
    });
    if (!!lm) this.board[x][y] = saveSquare;
    return moves;
  }

  getPotentialKingMoves(sq) {
    let moves = this.getSlideNJumpMoves(
      sq,
      V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
      "oneStep"
    );
    const c = this.turn;
    const oppCol = V.GetOppCol(c);
    if (
      !this.isAttacked(this.kingPos[c], oppCol) &&
      this.castleFlags[c].some(v => v < V.size.y)
    ) {
      moves = moves.concat(super.getCastleMoves(sq, null, true));
    }
    return moves;
  }

  getEpSquare(moveOrSquare) {
    if (typeof moveOrSquare === "string") {
      const square = moveOrSquare;
      if (square == "-") return undefined;
      return V.SquareToCoords(square);
    }
    const move = moveOrSquare;
    const s = move.start,
          e = move.end;
    const oppCol = V.GetOppCol(this.turn);
    if (
      s.y == e.y &&
      Math.abs(s.x - e.x) == 2 &&
      this.getPiece(s.x, s.y, oppCol) == V.PAWN
    ) {
      return {
        x: (s.x + e.x) / 2,
        y: s.y
      };
    }
    return undefined;
  }

  // Does m2 un-do m1 ? (to disallow undoing union moves)
  oppositeMoves(m1, m2) {
    return (
      !!m1 &&
      !(ChessRules.PIECES.includes(m2.appear[0].p)) &&
      m2.vanish.length == 1 &&
      m1.start.x == m2.end.x &&
      m1.end.x == m2.start.x &&
      m1.start.y == m2.end.y &&
      m1.end.y == m2.start.y
    );
  }

  // Do not consider checks for now (TODO)
  underCheck() {
    return false;
  }
  getCheckSquares() {
    return [];
  }
  filterValid(moves) {
    if (moves.length == 0) return [];
    const L = this.umoves.length; //at least 1: init from FEN
    return moves.filter(m => !this.oppositeMoves(this.umoves[L - 1], m));
  }

  play(move) {
    move.flags = JSON.stringify(this.aggregateFlags());
    this.epSquares.push(this.getEpSquare(move));
    // Check if the move is the last of the turn: all cases except releases
    if (!move.released) {
      // No more union releases available
      this.turn = V.GetOppCol(this.turn);
      this.movesCount++;
      this.lastMoveEnd.push(null);
    }
    else this.lastMoveEnd.push(Object.assign({ p: move.released }, move.end));
    V.PlayOnBoard(this.board, move);
    this.umoves.push(this.getUmove(move));
    this.postPlay(move);
  }

  postPlay(move) {
    if (move.vanish.length == 0)
      // A piece released just moved. Cannot be the king.
      return;
    const c = move.vanish[0].c;
    const piece = move.vanish[0].p;
    if (piece == V.KING)
      this.kingPos[c] = [move.appear[0].x, move.appear[0].y];
    this.updateCastleFlags(move, piece);
  }

  undo(move) {
    this.epSquares.pop();
    this.disaggregateFlags(JSON.parse(move.flags));
    V.UndoOnBoard(this.board, move);
    this.lastMoveEnd.pop();
    if (!move.released) {
      this.turn = V.GetOppCol(this.turn);
      this.movesCount--;
    }
    this.umoves.pop();
    this.postUndo(move);
  }

  postUndo(move) {
    if (this.getPiece(move.start.x, move.start.y) == V.KING)
      this.kingPos[this.turn] = [move.start.x, move.start.y];
  }

  getCurrentScore() {
    // Check kings: if one is dancing, the side lost
    // But, if both dancing, let's say it's a draw :-)
    const [kpW, kpB] = [this.kingPos['w'], this.kingPos['b']];
    const atKingPlace = [
      this.board[kpW[0]][kpW[1]].charAt(1),
      this.board[kpB[0]][kpB[1]].charAt(1)
    ];
    if (!atKingPlace.includes('k')) return "1/2";
    if (atKingPlace[0] != 'k') return "0-1";
    if (atKingPlace[1] != 'k') return "1-0";
    return "*";
  }

  getComputerMove() {
    let initMoves = this.getAllValidMoves();
    if (initMoves.length == 0) return null;
    // Loop until valid move is found (no blocked pawn released...)
    while (true) {
      let moves = JSON.parse(JSON.stringify(initMoves));
      let mvArray = [];
      let mv = null;
      // Just play random moves (for now at least. TODO?)
      while (moves.length > 0) {
        mv = moves[randInt(moves.length)];
        mvArray.push(mv);
        this.play(mv);
        if (!!mv.released)
          // A piece was just released from an union
          moves = this.getPotentialMovesFrom([mv.end.x, mv.end.y]);
        else break;
      }
      for (let i = mvArray.length - 1; i >= 0; i--) this.undo(mvArray[i]);
      if (!mv.released) return (mvArray.length > 1 ? mvArray : mvArray[0]);
    }
  }

  // NOTE: evalPosition() is wrong, but unused since bot plays at random

  getNotation(move) {
    if (move.appear.length == 2 && move.appear[0].p == V.KING)
      return (move.end.y < move.start.y ? "0-0-0" : "0-0");

    const c = this.turn;
    const L = this.lastMoveEnd.length;
    const lm = this.lastMoveEnd[L-1];
    let piece = null;
    if (!lm && move.vanish.length == 0)
      // When importing a game, the info move.released is lost
      piece = move.appear[0].p;
    else piece = (!!lm ? lm.p : move.vanish[0].p);
    if (!(ChessRules.PIECES.includes(piece))) {
      // Decode (moving) union
      const up = this.getUnionPieces(
        move.vanish.length > 0 ? move.vanish[0].c : move.appear[0].c, piece);
      piece = up[c]
    }

    // Basic move notation:
    let notation = piece.toUpperCase();
    if (
      this.board[move.end.x][move.end.y] != V.EMPTY ||
      (piece == V.PAWN && move.start.y != move.end.y)
    ) {
      notation += "x";
    }
    const finalSquare = V.CoordsToSquare(move.end);
    notation += finalSquare;

    // Add potential promotion indications:
    const firstLastRank = (c == 'w' ? [7, 0] : [0, 7]);
    if (move.end.x == firstLastRank[1] && piece == V.PAWN) {
      const up = this.getUnionPieces(move.appear[0].c, move.appear[0].p);
      notation += "=" + up[c].toUpperCase();
    }
    else if (
      move.end.x == firstLastRank[0] &&
      move.vanish.length > 0 &&
      ['c', 'd', 'e', 'f', 'g'].includes(move.vanish[0].p)
    ) {
      // We promoted an opponent's pawn
      const oppCol = V.GetOppCol(c);
      const up = this.getUnionPieces(move.appear[0].c, move.appear[0].p);
      notation += "=" + up[oppCol].toUpperCase();
    }

    return notation;
  }

};
Commit	Line	Data
173f11dc BA	1	import { ChessRules, PiPo, Move } from "@/base_rules";
	2	import { randInt } from "@/utils/alea";
	3
	4	export class PacosakoRules extends ChessRules {
	5
	6	static get IMAGE_EXTENSION() {
	7	return ".png";
	8	}
	9
	10	// Unions (left = white if upperCase, black otherwise)
	11	static get UNIONS() {
	12	return {
	13	a: ['p', 'p'],
	14	c: ['p', 'r'],
	15	d: ['p', 'n'],
	16	e: ['p', 'b'],
	17	f: ['p', 'q'],
	18	g: ['p', 'k'],
	19	h: ['r', 'r'],
	20	i: ['r', 'n'],
	21	j: ['r', 'b'],
	22	l: ['r', 'q'],
	23	m: ['r', 'k'],
	24	o: ['n', 'n'],
	25	s: ['n', 'b'],
	26	t: ['n', 'q'],
	27	u: ['n', 'k'],
	28	v: ['b', 'b'],
	29	w: ['b', 'q'],
	30	x: ['b', 'k'],
	31	y: ['q', 'q'],
	32	z: ['q', 'k']
	33	};
	34	}
	35
	36	static IsGoodPosition(position) {
	37	if (position.length == 0) return false;
	38	const rows = position.split("/");
	39	if (rows.length != V.size.x) return false;
	40	let kingSymb = ['k', 'g', 'm', 'u', 'x'];
	41	let kings = { 'k': 0, 'K': 0 };
	42	for (let row of rows) {
	43	let sumElts = 0;
	44	for (let i = 0; i < row.length; i++) {
	45	const lowR = row[i].toLowerCase
	46	if (!!(row[i].toLowerCase().match(/[a-z]/))) {
	47	sumElts++;
	48	if (kingSymb.includes(row[i])) kings['k']++;
	49	else if (kingSymb.some(s => row[i] == s.toUpperCase())) kings['K']++;
	50	}
	51	else {
	52	const num = parseInt(row[i], 10);
	53	if (isNaN(num) \|\| num <= 0) return false;
	54	sumElts += num;
	55	}
	56	}
	57	if (sumElts != V.size.y) return false;
	58	}
	59	// Both kings should be on board. Exactly one per color.
	60	if (Object.values(kings).some(v => v != 1)) return false;
	61	return true;
	62	}
	63
	64	getPpath(b) {
65	return "Pacosako/" + b;
66	}
67
4a209313	68	getPPpath(m) {
173f11dc BA	69	if (ChessRules.PIECES.includes(m.appear[0].p)) return super.getPPpath(m);
	70	// For an union, show only relevant piece:
	71	// The color must be deduced from the move: reaching final rank of who?
4a209313 BA	72	const color = (m.appear[0].x == 0 ? 'w' : 'b');
	73	const up = this.getUnionPieces(m.appear[0].c, m.appear[0].p);
	74	return "Pacosako/" + color + up[color];
173f11dc BA	75	}
	76
	77	canTake([x1, y1], [x2, y2]) {
4a209313 BA	78	const p1 = this.board[x1][y1].charAt(1);
	79	if (!(ChessRules.PIECES.includes(p1))) return false;
	80	const p2 = this.board[x2][y2].charAt(1);
	81	if (!(ChessRules.PIECES.includes(p2))) return true;
	82	const c1 = this.board[x1][y1].charAt(0);
	83	const c2 = this.board[x2][y2].charAt(0);
	84	return (c1 != c2);
173f11dc BA	85	}
	86
	87	canIplay(side, [x, y]) {
4a209313 BA	88	return (
	89	this.turn == side &&
	90	(
	91	!(ChessRules.PIECES.includes(this.board[x][y].charAt(1))) \|\|
	92	this.board[x][y].charAt(0) == side
	93	)
	94	);
173f11dc BA	95	}
	96
	97	scanKings(fen) {
	98	this.kingPos = { w: [-1, -1], b: [-1, -1] };
	99	const fenRows = V.ParseFen(fen).position.split("/");
	100	const startRow = { 'w': V.size.x - 1, 'b': 0 };
	101	const kingSymb = ['k', 'g', 'm', 'u', 'x'];
	102	for (let i = 0; i < fenRows.length; i++) {
	103	let k = 0;
	104	for (let j = 0; j < fenRows[i].length; j++) {
	105	const c = fenRows[i].charAt(j);
	106	if (kingSymb.includes(c))
	107	this.kingPos["b"] = [i, k];
	108	else if (kingSymb.some(s => c == s.toUpperCase()))
	109	this.kingPos["w"] = [i, k];
	110	else {
	111	const num = parseInt(fenRows[i].charAt(j), 10);
	112	if (!isNaN(num)) k += num - 1;
	113	}
	114	k++;
	115	}
	116	}
	117	}
	118
	119	setOtherVariables(fen) {
	120	super.setOtherVariables(fen);
	121	// Stack of "last move" only for intermediate chaining
	122	this.lastMoveEnd = [null];
4a209313 BA	123	// Local stack of non-capturing union moves:
	124	this.umoves = [];
	125	const umove = V.ParseFen(fen).umove;
	126	if (umove == "-") this.umoves.push(null);
	127	else {
	128	this.umoves.push({
	129	start: ChessRules.SquareToCoords(umove.substr(0, 2)),
	130	end: ChessRules.SquareToCoords(umove.substr(2))
	131	});
	132	}
	133	}
	134
	135	static IsGoodFen(fen) {
	136	if (!ChessRules.IsGoodFen(fen)) return false;
	137	const fenParts = fen.split(" ");
	138	if (fenParts.length != 6) return false;
	139	if (fenParts[5] != "-" && !fenParts[5].match(/^([a-h][1-8]){2}$/))
	140	return false;
	141	return true;
	142	}
	143
	144	getUmove(move) {
	145	if (
	146	move.vanish.length == 1 &&
	147	!(ChessRules.PIECES.includes(move.appear[0].p))
	148	) {
	149	// An union moving
	150	return { start: move.start, end: move.end };
	151	}
	152	return null;
	153	}
	154
	155	static ParseFen(fen) {
	156	const fenParts = fen.split(" ");
	157	return Object.assign(
	158	ChessRules.ParseFen(fen),
	159	{ umove: fenParts[5] }
	160	);
	161	}
	162
	163	static GenRandInitFen(randomness) {
	164	// Add empty umove
	165	return ChessRules.GenRandInitFen(randomness) + " -";
	166	}
	167
	168	getUmoveFen() {
	169	const L = this.umoves.length;
	170	return (
	171	!this.umoves[L - 1]
	172	? "-"
	173	: ChessRules.CoordsToSquare(this.umoves[L - 1].start) +
	174	ChessRules.CoordsToSquare(this.umoves[L - 1].end)
	175	);
	176	}
	177
	178	getFen() {
	179	return super.getFen() + " " + this.getUmoveFen();
	180	}
	181
	182	getFenForRepeat() {
	183	return super.getFenForRepeat() + "_" + this.getUmoveFen();
173f11dc BA	184	}
	185
	186	getColor(i, j) {
	187	const p = this.board[i][j].charAt(1);
	188	if (ChessRules.PIECES.includes(p)) return super.getColor(i, j);
4a209313	189	return this.turn; //union: I can use it, so it's "my" color...
173f11dc BA	190	}
	191
	192	getPiece(i, j, color) {
	193	const p = this.board[i][j].charAt(1);
173f11dc BA	194	if (ChessRules.PIECES.includes(p)) return p;
	195	const c = this.board[i][j].charAt(0);
	196	// NOTE: this.turn == HACK, but should work...
	197	color = color \|\| this.turn;
	198	return V.UNIONS[p][c == color ? 0 : 1];
	199	}
	200
	201	getUnionPieces(color, code) {
	202	const pieces = V.UNIONS[code];
	203	return {
	204	w: pieces[color == 'w' ? 0 : 1],
	205	b: pieces[color == 'b' ? 0 : 1]
	206	};
	207	}
	208
4a209313	209	// p1: white piece, p2: black piece
173f11dc BA	210	getUnionCode(p1, p2) {
	211	let uIdx = (
	212	Object.values(V.UNIONS).findIndex(v => v[0] == p1 && v[1] == p2)
	213	);
	214	const c = (uIdx >= 0 ? 'w' : 'b');
	215	if (uIdx == -1) {
	216	uIdx = (
	217	Object.values(V.UNIONS).findIndex(v => v[0] == p2 && v[1] == p1)
	218	);
	219	}
	220	return { c: c, p: Object.keys(V.UNIONS)[uIdx] };
	221	}
	222
	223	getBasicMove([sx, sy], [ex, ey], tr) {
4a209313 BA	224	const L = this.lastMoveEnd.length;
	225	const lm = this.lastMoveEnd[L-1];
	226	const piece = (!!lm ? lm.p : null);
	227	const initColor = (!!piece ? this.turn : this.board[sx][sy].charAt(0));
	228	const initPiece = (piece \|\| this.board[sx][sy].charAt(1));
	229	const c = this.turn;
	230	const oppCol = V.GetOppCol(c);
	231	if (!!tr && !(ChessRules.PIECES.includes(initPiece))) {
	232	// Transformation computed without taking union into account
	233	const up = this.getUnionPieces(initColor, initPiece);
	234	let args = [tr.p, up[oppCol]];
	235	if (c == 'b') args = args.reverse();
	236	const cp = this.getUnionCode(args[0], args[1]);
	237	tr.c = cp.c;
	238	tr.p = cp.p;
	239	}
173f11dc BA	240	// 4 cases : moving
	241	// - union to free square (other cases are illegal: return null)
	242	// - normal piece to free square,
	243	// to enemy normal piece, or
	244	// to union (releasing our piece)
	245	let mv = new Move({
4a209313 BA	246	start: { x: sx, y: sy },
	247	end: { x: ex, y: ey },
	248	vanish: []
	249	});
	250	if (!piece) {
	251	mv.vanish = [
173f11dc BA	252	new PiPo({
	253	x: sx,
	254	y: sy,
	255	c: initColor,
	256	p: initPiece
	257	})
4a209313 BA	258	];
4a209313 BA	259	}
173f11dc BA	260	// Treat free square cases first:
	261	if (this.board[ex][ey] == V.EMPTY) {
	262	mv.appear = [
	263	new PiPo({
	264	x: ex,
	265	y: ey,
4a209313	266	c: !!tr ? tr.c : initColor,
173f11dc BA	267	p: !!tr ? tr.p : initPiece
	268	})
	269	];
	270	return mv;
	271	}
	272	// Now the two cases with union / release:
	273	const destColor = this.board[ex][ey].charAt(0);
	274	const destPiece = this.board[ex][ey].charAt(1);
	275	mv.vanish.push(
	276	new PiPo({
	277	x: ex,
	278	y: ey,
	279	c: destColor,
	280	p: destPiece
	281	})
	282	);
	283	if (ChessRules.PIECES.includes(destPiece)) {
	284	// Normal piece: just create union
4a209313 BA	285	let args = [!!tr ? tr.p : initPiece, destPiece];
	286	if (c == 'b') args = args.reverse();
	287	const cp = this.getUnionCode(args[0], args[1]);
173f11dc BA	288	mv.appear = [
	289	new PiPo({
	290	x: ex,
	291	y: ey,
	292	c: cp.c,
	293	p: cp.p
	294	})
	295	];
	296	return mv;
	297	}
	298	// Releasing a piece in an union: keep track of released piece
	299	const up = this.getUnionPieces(destColor, destPiece);
4a209313 BA	300	let args = [!!tr ? tr.p : initPiece, up[oppCol]];
	301	if (c == 'b') args = args.reverse();
	302	const cp = this.getUnionCode(args[0], args[1]);
173f11dc BA	303	mv.appear = [
	304	new PiPo({
	305	x: ex,
	306	y: ey,
	307	c: cp.c,
	308	p: cp.p
	309	})
	310	];
	311	mv.released = up[c];
	312	return mv;
	313	}
	314
4a209313	315	getPotentialMovesFrom([x, y]) {
173f11dc BA	316	const L = this.lastMoveEnd.length;
173f11dc BA	317	const lm = this.lastMoveEnd[L-1];
4a209313 BA	318	if (!!lm && (x != lm.x \|\| y != lm.y)) return [];
4a209313 BA	319	const piece = (!!lm ? lm.p : this.getPiece(x, y));
173f11dc	320	if (!!lm) {
4a209313	321	var saveSquare = this.board[x][y];
173f11dc BA	322	this.board[x][y] = this.turn + piece;
	323	}
	324	let baseMoves = [];
	325	switch (piece \|\| this.getPiece(x, y)) {
	326	case V.PAWN:
	327	baseMoves = this.getPotentialPawnMoves([x, y]);
	328	break;
	329	case V.ROOK:
	330	baseMoves = this.getPotentialRookMoves([x, y]);
	331	break;
	332	case V.KNIGHT:
	333	baseMoves = this.getPotentialKnightMoves([x, y]);
	334	break;
	335	case V.BISHOP:
	336	baseMoves = this.getPotentialBishopMoves([x, y]);
	337	break;
	338	case V.QUEEN:
	339	baseMoves = this.getPotentialQueenMoves([x, y]);
	340	break;
	341	case V.KING:
	342	baseMoves = this.getPotentialKingMoves([x, y]);
	343	break;
	344	}
	345	// When a pawn in an union reaches final rank with a non-standard
	346	// promotion move: apply promotion anyway
	347	let moves = [];
4a209313 BA	348	const c = this.turn;
	349	const oppCol = V.GetOppCol(c);
	350	const oppLastRank = (c == 'w' ? 7 : 0);
173f11dc	351	baseMoves.forEach(m => {
4a209313 BA	352	if (
	353	m.end.x == oppLastRank &&
	354	['c', 'd', 'e', 'f', 'g'].includes(m.appear[0].p)
	355	) {
	356	// Move to first rank, which is last rank for opponent's pawn.
	357	// => Show promotion choices.
	358	// Find our piece in union (not a pawn)
	359	const up = this.getUnionPieces(m.appear[0].c, m.appear[0].p);
	360	// merge with all potential promotion pieces + push (loop)
	361	for (let promotionPiece of [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN]) {
	362	let args = [up[c], promotionPiece];
	363	if (c == 'b') args = args.reverse();
	364	const cp = this.getUnionCode(args[0], args[1]);
	365	let cpMove = JSON.parse(JSON.stringify(m));
	366	cpMove.appear[0].c = cp.c;
	367	cpMove.appear[0].p = cp.p;
	368	moves.push(cpMove);
	369	}
	370	}
	371	else {
	372	if (
	373	m.vanish.length > 0 &&
	374	m.vanish[0].p == V.PAWN &&
	375	m.start.y != m.end.y &&
	376	this.board[m.end.x][m.end.y] == V.EMPTY
	377	) {
	378	if (!!lm)
	379	// No en-passant inside a chaining
	380	return;
	381	// Fix en-passant capture: union type, maybe released piece too
	382	const cs = [m.end.x + (c == 'w' ? 1 : -1), m.end.y];
	383	const color = this.board[cs[0]][cs[1]].charAt(0);
	384	const code = this.board[cs[0]][cs[1]].charAt(1);
	385	if (code == V.PAWN) {
	386	// Simple en-passant capture (usual: just form union)
	387	m.appear[0].c = 'w';
	388	m.appear[0].p = 'a';
	389	}
	390	else {
	391	// An union pawn + something juste moved two squares
	392	const up = this.getUnionPieces(color, code);
	393	m.released = up[c];
	394	let args = [V.PAWN, up[oppCol]];
	395	if (c == 'b') args = args.reverse();
	396	const cp = this.getUnionCode(args[0], args[1]);
	397	m.appear[0].c = cp.c;
	398	m.appear[0].p = cp.p;
	399	}
	400	}
	401	moves.push(m);
	402	}
173f11dc	403	});
4a209313	404	if (!!lm) this.board[x][y] = saveSquare;
173f11dc BA	405	return moves;
	406	}
	407
231bba39 BA	408	getPotentialKingMoves(sq) {
	409	let moves = this.getSlideNJumpMoves(
	410	sq,
	411	V.steps[V.ROOK].concat(V.steps[V.BISHOP]),
	412	"oneStep"
	413	);
	414	const c = this.turn;
	415	const oppCol = V.GetOppCol(c);
	416	if (
	417	!this.isAttacked(this.kingPos[c], oppCol) &&
	418	this.castleFlags[c].some(v => v < V.size.y)
	419	) {
	420	moves = moves.concat(super.getCastleMoves(sq, null, true));
	421	}
	422	return moves;
	423	}
	424
4a209313 BA	425	getEpSquare(moveOrSquare) {
	426	if (typeof moveOrSquare === "string") {
	427	const square = moveOrSquare;
	428	if (square == "-") return undefined;
	429	return V.SquareToCoords(square);
	430	}
	431	const move = moveOrSquare;
	432	const s = move.start,
	433	e = move.end;
	434	const oppCol = V.GetOppCol(this.turn);
	435	if (
	436	s.y == e.y &&
	437	Math.abs(s.x - e.x) == 2 &&
	438	this.getPiece(s.x, s.y, oppCol) == V.PAWN
	439	) {
	440	return {
	441	x: (s.x + e.x) / 2,
	442	y: s.y
	443	};
	444	}
	445	return undefined;
	446	}
	447
	448	// Does m2 un-do m1 ? (to disallow undoing union moves)
	449	oppositeMoves(m1, m2) {
	450	return (
	451	!!m1 &&
	452	!(ChessRules.PIECES.includes(m2.appear[0].p)) &&
	453	m2.vanish.length == 1 &&
	454	m1.start.x == m2.end.x &&
	455	m1.end.x == m2.start.x &&
	456	m1.start.y == m2.end.y &&
	457	m1.end.y == m2.start.y
	458	);
	459	}
	460
	461	// Do not consider checks for now (TODO)
	462	underCheck() {
	463	return false;
	464	}
	465	getCheckSquares() {
	466	return [];
	467	}
	468	filterValid(moves) {
	469	if (moves.length == 0) return [];
	470	const L = this.umoves.length; //at least 1: init from FEN
	471	return moves.filter(m => !this.oppositeMoves(this.umoves[L - 1], m));
	472	}
	473
173f11dc	474	play(move) {
c27fcf89	475	move.flags = JSON.stringify(this.aggregateFlags());
173f11dc BA	476	this.epSquares.push(this.getEpSquare(move));
173f11dc BA	477	// Check if the move is the last of the turn: all cases except releases
4a209313	478	if (!move.released) {
173f11dc BA	479	// No more union releases available
	480	this.turn = V.GetOppCol(this.turn);
	481	this.movesCount++;
	482	this.lastMoveEnd.push(null);
	483	}
4a209313	484	else this.lastMoveEnd.push(Object.assign({ p: move.released }, move.end));
173f11dc	485	V.PlayOnBoard(this.board, move);
4a209313	486	this.umoves.push(this.getUmove(move));
3cf54395	487	this.postPlay(move);
173f11dc BA	488	}
173f11dc BA	489
4a209313 BA	490	postPlay(move) {
	491	if (move.vanish.length == 0)
	492	// A piece released just moved. Cannot be the king.
	493	return;
	494	const c = move.vanish[0].c;
	495	const piece = move.vanish[0].p;
	496	if (piece == V.KING)
	497	this.kingPos[c] = [move.appear[0].x, move.appear[0].y];
	498	this.updateCastleFlags(move, piece);
	499	}
	500
173f11dc BA	501	undo(move) {
173f11dc BA	502	this.epSquares.pop();
c27fcf89	503	this.disaggregateFlags(JSON.parse(move.flags));
173f11dc BA	504	V.UndoOnBoard(this.board, move);
173f11dc BA	505	this.lastMoveEnd.pop();
4a209313	506	if (!move.released) {
173f11dc BA	507	this.turn = V.GetOppCol(this.turn);
	508	this.movesCount--;
	509	}
4a209313	510	this.umoves.pop();
3cf54395	511	this.postUndo(move);
173f11dc BA	512	}
173f11dc BA	513
4a209313 BA	514	postUndo(move) {
	515	if (this.getPiece(move.start.x, move.start.y) == V.KING)
	516	this.kingPos[this.turn] = [move.start.x, move.start.y];
	517	}
	518
173f11dc BA	519	getCurrentScore() {
173f11dc BA	520	// Check kings: if one is dancing, the side lost
4a209313	521	// But, if both dancing, let's say it's a draw :-)
173f11dc	522	const [kpW, kpB] = [this.kingPos['w'], this.kingPos['b']];
4a209313 BA	523	const atKingPlace = [
	524	this.board[kpW[0]][kpW[1]].charAt(1),
	525	this.board[kpB[0]][kpB[1]].charAt(1)
	526	];
	527	if (!atKingPlace.includes('k')) return "1/2";
	528	if (atKingPlace[0] != 'k') return "0-1";
	529	if (atKingPlace[1] != 'k') return "1-0";
173f11dc BA	530	return "*";
	531	}
	532
	533	getComputerMove() {
4a209313 BA	534	let initMoves = this.getAllValidMoves();
	535	if (initMoves.length == 0) return null;
	536	// Loop until valid move is found (no blocked pawn released...)
	537	while (true) {
	538	let moves = JSON.parse(JSON.stringify(initMoves));
	539	let mvArray = [];
	540	let mv = null;
	541	// Just play random moves (for now at least. TODO?)
	542	while (moves.length > 0) {
	543	mv = moves[randInt(moves.length)];
	544	mvArray.push(mv);
	545	this.play(mv);
	546	if (!!mv.released)
	547	// A piece was just released from an union
	548	moves = this.getPotentialMovesFrom([mv.end.x, mv.end.y]);
	549	else break;
	550	}
	551	for (let i = mvArray.length - 1; i >= 0; i--) this.undo(mvArray[i]);
	552	if (!mv.released) return (mvArray.length > 1 ? mvArray : mvArray[0]);
173f11dc	553	}
173f11dc BA	554	}
	555
	556	// NOTE: evalPosition() is wrong, but unused since bot plays at random
	557
	558	getNotation(move) {
4a209313 BA	559	if (move.appear.length == 2 && move.appear[0].p == V.KING)
	560	return (move.end.y < move.start.y ? "0-0-0" : "0-0");
	561
	562	const c = this.turn;
	563	const L = this.lastMoveEnd.length;
	564	const lm = this.lastMoveEnd[L-1];
	565	let piece = null;
	566	if (!lm && move.vanish.length == 0)
	567	// When importing a game, the info move.released is lost
	568	piece = move.appear[0].p;
	569	else piece = (!!lm ? lm.p : move.vanish[0].p);
	570	if (!(ChessRules.PIECES.includes(piece))) {
	571	// Decode (moving) union
	572	const up = this.getUnionPieces(
	573	move.vanish.length > 0 ? move.vanish[0].c : move.appear[0].c, piece);
	574	piece = up[c]
	575	}
	576
	577	// Basic move notation:
	578	let notation = piece.toUpperCase();
	579	if (
	580	this.board[move.end.x][move.end.y] != V.EMPTY \|\|
	581	(piece == V.PAWN && move.start.y != move.end.y)
	582	) {
	583	notation += "x";
	584	}
	585	const finalSquare = V.CoordsToSquare(move.end);
	586	notation += finalSquare;
	587
	588	// Add potential promotion indications:
	589	const firstLastRank = (c == 'w' ? [7, 0] : [0, 7]);
	590	if (move.end.x == firstLastRank[1] && piece == V.PAWN) {
	591	const up = this.getUnionPieces(move.appear[0].c, move.appear[0].p);
	592	notation += "=" + up[c].toUpperCase();
	593	}
	594	else if (
	595	move.end.x == firstLastRank[0] &&
	596	move.vanish.length > 0 &&
	597	['c', 'd', 'e', 'f', 'g'].includes(move.vanish[0].p)
	598	) {
	599	// We promoted an opponent's pawn
	600	const oppCol = V.GetOppCol(c);
	601	const up = this.getUnionPieces(move.appear[0].c, move.appear[0].p);
	602	notation += "=" + up[oppCol].toUpperCase();
	603	}
	604
	605	return notation;
173f11dc BA	606	}
	607
	608	};