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

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

export class CoregalRules extends ChessRules {
  static IsGoodPosition(position) {
    if (!super.IsGoodPosition(position)) return false;
    // Check that at least one queen of each color is there:
    let queens = {};
    for (let row of rows) {
      for (let i = 0; i < row.length; i++)
        if (['Q','q'].includes(row[i])) queens[row[i]] = true;
    }
    if (Object.keys(queens).length != 2) return false;
    return true;
  }

  static IsGoodFlags(flags) {
    return !!flags.match(/^[a-z]{8,8}$/);
  }

  getCheckSquares(color) {
    let squares = [];
    const oppCol = V.GetOppCol(color);
    if (this.isAttacked(this.kingPos[color], oppCol))
      squares.push(this.kingPos[color]);
    for (let i=0; i<V.size.x; i++) {
      for (let j=0; j<V.size.y; j++) {
        if (
          this.getColor(i, j) == color &&
          this.getPiece(i, j) == V.QUEEN &&
          this.isAttacked([i, j], oppCol)
        ) {
          squares.push([i, j]);
        }
      }
    }
    return squares;
  }

  static GenRandInitFen(randomness) {
    if (randomness == 0)
      // Castle flags here indicate pieces positions (if can castle)
      return "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0 adehadeh -";

    let pieces = { w: new Array(8), b: new Array(8) };
    let flags = "";
    for (let c of ["w", "b"]) {
      if (c == 'b' && randomness == 1) {
        pieces['b'] = pieces['w'];
        flags += flags;
        break;
      }

      // Get random squares for king and queen between b and g files
      let randIndex = randInt(6);
      let kingPos = randIndex + 1;
      randIndex = randInt(5);
      if (randIndex >= kingPos) randIndex++;
      let queenPos = randIndex + 1;

      // Get random squares for rooks to the left and right of the queen
      // and king: not all squares of the same colors (for bishops).
      const minQR = Math.min(kingPos, queenPos);
      const maxQR = Math.max(kingPos, queenPos);
      let rook1Pos = randInt(minQR);
      let rook2Pos = 7 - randInt(7 - maxQR);

      // Now, if we are unlucky all these 4 pieces may be on the same color.
      const rem2 = [kingPos, queenPos, rook1Pos, rook2Pos].map(pos => pos % 2);
      if (rem2.every(r => r == 0) || rem2.every(r => r == 1)) {
        // Shift a random of these pieces to the left or right
        switch (randInt(4)) {
          case 0:
            if (rook1Pos == 0) rook1Pos++;
            else rook1Pos--;
            break;
          case 1:
            if (Math.random() < 0.5) kingPos++;
            else kingPos--;
            break;
          case 2:
            if (Math.random() < 0.5) queenPos++;
            else queenPos--;
            break;
          case 3:
            if (rook2Pos == 7) rook2Pos--;
            else rook2Pos++;
            break;
        }
      }
      let bishop1Options = { 0: true, 2: true, 4: true, 6: true };
      let bishop2Options = { 1: true, 3: true, 5: true, 7: true };
      [kingPos, queenPos, rook1Pos, rook2Pos].forEach(pos => {
        if (!!bishop1Options[pos]) delete bishop1Options[pos];
        else if (!!bishop2Options[pos]) delete bishop2Options[pos];
      });
      const bishop1Pos = parseInt(sample(Object.keys(bishop1Options), 1)[0]);
      const bishop2Pos = parseInt(sample(Object.keys(bishop2Options), 1)[0]);

      // Knights' positions are now determined
      const forbidden = [
        kingPos, queenPos, rook1Pos, rook2Pos, bishop1Pos, bishop2Pos
      ];
      const [knight1Pos, knight2Pos] =
        ArrayFun.range(8).filter(pos => !forbidden.includes(pos));

      pieces[c][rook1Pos] = "r";
      pieces[c][knight1Pos] = "n";
      pieces[c][bishop1Pos] = "b";
      pieces[c][queenPos] = "q";
      pieces[c][kingPos] = "k";
      pieces[c][bishop2Pos] = "b";
      pieces[c][knight2Pos] = "n";
      pieces[c][rook2Pos] = "r";
      flags += V.CoordToColumn(rook1Pos) + V.CoordToColumn(queenPos) +
               V.CoordToColumn(kingPos) + V.CoordToColumn(rook2Pos);
    }
    // Add turn + flags + enpassant
    return (
      pieces["b"].join("") +
      "/pppppppp/8/8/8/8/PPPPPPPP/" +
      pieces["w"].join("").toUpperCase() +
      " w 0 " + flags + " -"
    );
  }

  setFlags(fenflags) {
    // white a-castle, h-castle, black a-castle, h-castle
    this.castleFlags = { w: [...Array(4)], b: [...Array(4)] };
    for (let i = 0; i < 8; i++) {
      this.castleFlags[i < 4 ? "w" : "b"][i % 4] =
        V.ColumnToCoord(fenflags.charAt(i));
    }
  }

  getPotentialQueenMoves(sq) {
    return super.getPotentialQueenMoves(sq).concat(this.getCastleMoves(sq));
  }

  getCastleMoves([x, y], castleInCheck) {
    return [];
//    const c = this.getColor(x, y);
//    if (x != (c == "w" ? V.size.x - 1 : 0) || y != this.INIT_COL_KING[c])
//      return []; //x isn't first rank, or king has moved (shortcut)
//
//    // Castling ?
//    const oppCol = V.GetOppCol(c);
//    let moves = [];
//    let i = 0;
//    // King, then rook:
//    const finalSquares = [
//      [2, 3],
//      [V.size.y - 2, V.size.y - 3]
//    ];
//    castlingCheck: for (
//      let castleSide = 0;
//      castleSide < 2;
//      castleSide++ //large, then small
//    ) {
//      if (this.castleFlags[c][castleSide] >= V.size.y) continue;
//      // If this code is reached, rooks and king are on initial position
//
//      // NOTE: in some variants this is not a rook, but let's keep variable name
//      const rookPos = this.castleFlags[c][castleSide];
//      const castlingPiece = this.getPiece(x, rookPos);
//      if (this.getColor(x, rookPos) != c)
//        // Rook is here but changed color (see Benedict)
//        continue;
//
//      // Nothing on the path of the king ? (and no checks)
//      const finDist = finalSquares[castleSide][0] - y;
//      let step = finDist / Math.max(1, Math.abs(finDist));
//      i = y;
//      do {
//        if (
//          (!castleInCheck && this.isAttacked([x, i], oppCol)) ||
//          (this.board[x][i] != V.EMPTY &&
//            // NOTE: next check is enough, because of chessboard constraints
//            (this.getColor(x, i) != c ||
//              ![V.KING, castlingPiece].includes(this.getPiece(x, i))))
//        ) {
//          continue castlingCheck;
//        }
//        i += step;
//      } while (i != finalSquares[castleSide][0]);
//
//      // Nothing on the path to the rook?
//      step = castleSide == 0 ? -1 : 1;
//      for (i = y + step; i != rookPos; i += step) {
//        if (this.board[x][i] != V.EMPTY) continue castlingCheck;
//      }
//
//      // Nothing on final squares, except maybe king and castling rook?
//      for (i = 0; i < 2; i++) {
//        if (
//          this.board[x][finalSquares[castleSide][i]] != V.EMPTY &&
//          this.getPiece(x, finalSquares[castleSide][i]) != V.KING &&
//          finalSquares[castleSide][i] != rookPos
//        ) {
//          continue castlingCheck;
//        }
//      }
//
//      // If this code is reached, castle is valid
//      moves.push(
//        new Move({
//          appear: [
//            new PiPo({ x: x, y: finalSquares[castleSide][0], p: V.KING, c: c }),
//            new PiPo({ x: x, y: finalSquares[castleSide][1], p: castlingPiece, c: c })
//          ],
//          vanish: [
//            new PiPo({ x: x, y: y, p: V.KING, c: c }),
//            new PiPo({ x: x, y: rookPos, p: castlingPiece, c: c })
//          ],
//          end:
//            Math.abs(y - rookPos) <= 2
//              ? { x: x, y: rookPos }
//              : { x: x, y: y + 2 * (castleSide == 0 ? -1 : 1) }
//        })
//      );
//    }
//
//    return moves;
  }

  underCheck(color) {
    const oppCol = V.GetOppCol(color);
    if (this.isAttacked(this.kingPos[color], oppCol)) return true;
    for (let i=0; i<V.size.x; i++) {
      for (let j=0; j<V.size.y; j++) {
        if (
          this.getColor(i, j) == color &&
          this.getPiece(i, j) == V.QUEEN &&
          this.isAttacked([i, j], oppCol)
        ) {
          return true;
        }
      }
    }
    return false;
  }

  updateCastleFlags(move, piece) {
//    const c = V.GetOppCol(this.turn);
//    const firstRank = (c == "w" ? V.size.x - 1 : 0);
//    // Update castling flags if rooks are moved
//    const oppCol = V.GetOppCol(c);
//    const oppFirstRank = V.size.x - 1 - firstRank;
//    if (piece == V.KING && move.appear.length > 0)
//      this.castleFlags[c] = [V.size.y, V.size.y];
//    else if (
//      move.start.x == firstRank && //our rook moves?
//      this.castleFlags[c].includes(move.start.y)
//    ) {
//      const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1);
//      this.castleFlags[c][flagIdx] = V.size.y;
//    } else if (
//      move.end.x == oppFirstRank && //we took opponent rook?
//      this.castleFlags[oppCol].includes(move.end.y)
//    ) {
//      const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1);
//      this.castleFlags[oppCol][flagIdx] = V.size.y;
//    }
  }

  // NOTE: do not set queen value to 1000 or so, because there may be several.
};
Commit	Line	Data
	1	import { ChessRules } from "@/base_rules";
	2	import { ArrayFun } from "@/utils/array";
	3	import { randInt, sample } from "@/utils/alea";
	4
	5	export class CoregalRules extends ChessRules {
	6	static IsGoodPosition(position) {
	7	if (!super.IsGoodPosition(position)) return false;
	8	// Check that at least one queen of each color is there:
	9	let queens = {};
	10	for (let row of rows) {
	11	for (let i = 0; i < row.length; i++)
	12	if (['Q','q'].includes(row[i])) queens[row[i]] = true;
	13	}
	14	if (Object.keys(queens).length != 2) return false;
	15	return true;
	16	}
	17
	18	static IsGoodFlags(flags) {
	19	return !!flags.match(/^[a-z]{8,8}$/);
	20	}
	21
	22	getCheckSquares(color) {
	23	let squares = [];
	24	const oppCol = V.GetOppCol(color);
	25	if (this.isAttacked(this.kingPos[color], oppCol))
	26	squares.push(this.kingPos[color]);
	27	for (let i=0; i<V.size.x; i++) {
	28	for (let j=0; j<V.size.y; j++) {
	29	if (
	30	this.getColor(i, j) == color &&
	31	this.getPiece(i, j) == V.QUEEN &&
	32	this.isAttacked([i, j], oppCol)
	33	) {
	34	squares.push([i, j]);
	35	}
	36	}
	37	}
	38	return squares;
	39	}
	40
	41	static GenRandInitFen(randomness) {
	42	if (randomness == 0)
	43	// Castle flags here indicate pieces positions (if can castle)
	44	return "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w 0 adehadeh -";
	45
	46	let pieces = { w: new Array(8), b: new Array(8) };
	47	let flags = "";
	48	for (let c of ["w", "b"]) {
	49	if (c == 'b' && randomness == 1) {
	50	pieces['b'] = pieces['w'];
	51	flags += flags;
	52	break;
	53	}
	54
	55	// Get random squares for king and queen between b and g files
	56	let randIndex = randInt(6);
	57	let kingPos = randIndex + 1;
	58	randIndex = randInt(5);
	59	if (randIndex >= kingPos) randIndex++;
	60	let queenPos = randIndex + 1;
	61
	62	// Get random squares for rooks to the left and right of the queen
	63	// and king: not all squares of the same colors (for bishops).
	64	const minQR = Math.min(kingPos, queenPos);
	65	const maxQR = Math.max(kingPos, queenPos);
	66	let rook1Pos = randInt(minQR);
	67	let rook2Pos = 7 - randInt(7 - maxQR);
	68
	69	// Now, if we are unlucky all these 4 pieces may be on the same color.
	70	const rem2 = [kingPos, queenPos, rook1Pos, rook2Pos].map(pos => pos % 2);
	71	if (rem2.every(r => r == 0) \|\| rem2.every(r => r == 1)) {
	72	// Shift a random of these pieces to the left or right
	73	switch (randInt(4)) {
	74	case 0:
	75	if (rook1Pos == 0) rook1Pos++;
	76	else rook1Pos--;
	77	break;
	78	case 1:
	79	if (Math.random() < 0.5) kingPos++;
	80	else kingPos--;
	81	break;
	82	case 2:
	83	if (Math.random() < 0.5) queenPos++;
	84	else queenPos--;
	85	break;
	86	case 3:
	87	if (rook2Pos == 7) rook2Pos--;
	88	else rook2Pos++;
	89	break;
	90	}
	91	}
	92	let bishop1Options = { 0: true, 2: true, 4: true, 6: true };
	93	let bishop2Options = { 1: true, 3: true, 5: true, 7: true };
	94	[kingPos, queenPos, rook1Pos, rook2Pos].forEach(pos => {
	95	if (!!bishop1Options[pos]) delete bishop1Options[pos];
	96	else if (!!bishop2Options[pos]) delete bishop2Options[pos];
	97	});
	98	const bishop1Pos = parseInt(sample(Object.keys(bishop1Options), 1)[0]);
	99	const bishop2Pos = parseInt(sample(Object.keys(bishop2Options), 1)[0]);
	100
	101	// Knights' positions are now determined
	102	const forbidden = [
	103	kingPos, queenPos, rook1Pos, rook2Pos, bishop1Pos, bishop2Pos
	104	];
	105	const [knight1Pos, knight2Pos] =
	106	ArrayFun.range(8).filter(pos => !forbidden.includes(pos));
	107
	108	pieces[c][rook1Pos] = "r";
	109	pieces[c][knight1Pos] = "n";
	110	pieces[c][bishop1Pos] = "b";
	111	pieces[c][queenPos] = "q";
	112	pieces[c][kingPos] = "k";
	113	pieces[c][bishop2Pos] = "b";
	114	pieces[c][knight2Pos] = "n";
	115	pieces[c][rook2Pos] = "r";
	116	flags += V.CoordToColumn(rook1Pos) + V.CoordToColumn(queenPos) +
	117	V.CoordToColumn(kingPos) + V.CoordToColumn(rook2Pos);
	118	}
	119	// Add turn + flags + enpassant
	120	return (
	121	pieces["b"].join("") +
	122	"/pppppppp/8/8/8/8/PPPPPPPP/" +
	123	pieces["w"].join("").toUpperCase() +
	124	" w 0 " + flags + " -"
	125	);
	126	}
	127
	128	setFlags(fenflags) {
	129	// white a-castle, h-castle, black a-castle, h-castle
	130	this.castleFlags = { w: [...Array(4)], b: [...Array(4)] };
	131	for (let i = 0; i < 8; i++) {
	132	this.castleFlags[i < 4 ? "w" : "b"][i % 4] =
	133	V.ColumnToCoord(fenflags.charAt(i));
	134	}
	135	}
	136
	137	getPotentialQueenMoves(sq) {
	138	return super.getPotentialQueenMoves(sq).concat(this.getCastleMoves(sq));
	139	}
	140
	141	getCastleMoves([x, y], castleInCheck) {
	142	return [];
	143	// const c = this.getColor(x, y);
	144	// if (x != (c == "w" ? V.size.x - 1 : 0) \|\| y != this.INIT_COL_KING[c])
	145	// return []; //x isn't first rank, or king has moved (shortcut)
	146	//
	147	// // Castling ?
	148	// const oppCol = V.GetOppCol(c);
	149	// let moves = [];
	150	// let i = 0;
	151	// // King, then rook:
	152	// const finalSquares = [
	153	// [2, 3],
	154	// [V.size.y - 2, V.size.y - 3]
	155	// ];
	156	// castlingCheck: for (
	157	// let castleSide = 0;
	158	// castleSide < 2;
	159	// castleSide++ //large, then small
	160	// ) {
	161	// if (this.castleFlags[c][castleSide] >= V.size.y) continue;
	162	// // If this code is reached, rooks and king are on initial position
	163	//
	164	// // NOTE: in some variants this is not a rook, but let's keep variable name
	165	// const rookPos = this.castleFlags[c][castleSide];
	166	// const castlingPiece = this.getPiece(x, rookPos);
	167	// if (this.getColor(x, rookPos) != c)
	168	// // Rook is here but changed color (see Benedict)
	169	// continue;
	170	//
	171	// // Nothing on the path of the king ? (and no checks)
	172	// const finDist = finalSquares[castleSide][0] - y;
	173	// let step = finDist / Math.max(1, Math.abs(finDist));
	174	// i = y;
	175	// do {
	176	// if (
	177	// (!castleInCheck && this.isAttacked([x, i], oppCol)) \|\|
	178	// (this.board[x][i] != V.EMPTY &&
	179	// // NOTE: next check is enough, because of chessboard constraints
	180	// (this.getColor(x, i) != c \|\|
	181	// ![V.KING, castlingPiece].includes(this.getPiece(x, i))))
	182	// ) {
	183	// continue castlingCheck;
	184	// }
	185	// i += step;
	186	// } while (i != finalSquares[castleSide][0]);
	187	//
	188	// // Nothing on the path to the rook?
	189	// step = castleSide == 0 ? -1 : 1;
	190	// for (i = y + step; i != rookPos; i += step) {
	191	// if (this.board[x][i] != V.EMPTY) continue castlingCheck;
	192	// }
	193	//
	194	// // Nothing on final squares, except maybe king and castling rook?
	195	// for (i = 0; i < 2; i++) {
	196	// if (
	197	// this.board[x][finalSquares[castleSide][i]] != V.EMPTY &&
	198	// this.getPiece(x, finalSquares[castleSide][i]) != V.KING &&
	199	// finalSquares[castleSide][i] != rookPos
	200	// ) {
	201	// continue castlingCheck;
	202	// }
	203	// }
	204	//
	205	// // If this code is reached, castle is valid
	206	// moves.push(
	207	// new Move({
	208	// appear: [
	209	// new PiPo({ x: x, y: finalSquares[castleSide][0], p: V.KING, c: c }),
	210	// new PiPo({ x: x, y: finalSquares[castleSide][1], p: castlingPiece, c: c })
	211	// ],
	212	// vanish: [
	213	// new PiPo({ x: x, y: y, p: V.KING, c: c }),
	214	// new PiPo({ x: x, y: rookPos, p: castlingPiece, c: c })
	215	// ],
	216	// end:
	217	// Math.abs(y - rookPos) <= 2
	218	// ? { x: x, y: rookPos }
	219	// : { x: x, y: y + 2 * (castleSide == 0 ? -1 : 1) }
	220	// })
	221	// );
	222	// }
	223	//
	224	// return moves;
	225	}
	226
	227	underCheck(color) {
	228	const oppCol = V.GetOppCol(color);
	229	if (this.isAttacked(this.kingPos[color], oppCol)) return true;
	230	for (let i=0; i<V.size.x; i++) {
	231	for (let j=0; j<V.size.y; j++) {
	232	if (
	233	this.getColor(i, j) == color &&
	234	this.getPiece(i, j) == V.QUEEN &&
	235	this.isAttacked([i, j], oppCol)
	236	) {
	237	return true;
	238	}
	239	}
	240	}
	241	return false;
	242	}
	243
	244	updateCastleFlags(move, piece) {
	245	// const c = V.GetOppCol(this.turn);
	246	// const firstRank = (c == "w" ? V.size.x - 1 : 0);
	247	// // Update castling flags if rooks are moved
	248	// const oppCol = V.GetOppCol(c);
	249	// const oppFirstRank = V.size.x - 1 - firstRank;
	250	// if (piece == V.KING && move.appear.length > 0)
	251	// this.castleFlags[c] = [V.size.y, V.size.y];
	252	// else if (
	253	// move.start.x == firstRank && //our rook moves?
	254	// this.castleFlags[c].includes(move.start.y)
	255	// ) {
	256	// const flagIdx = (move.start.y == this.castleFlags[c][0] ? 0 : 1);
	257	// this.castleFlags[c][flagIdx] = V.size.y;
	258	// } else if (
	259	// move.end.x == oppFirstRank && //we took opponent rook?
	260	// this.castleFlags[oppCol].includes(move.end.y)
	261	// ) {
	262	// const flagIdx = (move.end.y == this.castleFlags[oppCol][0] ? 0 : 1);
	263	// this.castleFlags[oppCol][flagIdx] = V.size.y;
	264	// }
	265	}
	266
	267	// NOTE: do not set queen value to 1000 or so, because there may be several.
	268	};