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

import { ChessRules, PiPo } from "@/base_rules";

export class SchessRules extends ChessRules {

  static get PawnSpecs() {
    return Object.assign(
      {},
      ChessRules.PawnSpecs,
      {
        promotions:
          ChessRules.PawnSpecs.promotions.concat([V.HAWK, V.ELEPHANT])
      }
    );
  }

  static get HAWK() {
    return 'h';
  }

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

  static get NOTHING() {
    return 'o';
  }

  static get PIECES() {
    return ChessRules.PIECES.concat([V.HAWK, V.ELEPHANT]);
  }

  getPpath(b) {
    if ([V.HAWK, V.ELEPHANT, V.NOTHING].includes(b[1])) return "Schess/" + b;
    return b;
  }

  static IsGoodFen(fen) {
    if (!ChessRules.IsGoodFen(fen)) return false;
    const fenParsed = V.ParseFen(fen);
    // Check pocket state
    if (!fenParsed.pocket || !fenParsed.pocket.match(/^[0-1]{4,4}$/))
      return false;
    return true;
  }

  static IsGoodFlags(flags) {
    // 4 for castle + 16 for generators
    return !!flags.match(/^[a-z]{4,4}[01]{16,16}$/);
  }

  setFlags(fenflags) {
    super.setFlags(fenflags); //castleFlags
    this.pieceFlags = {
      w: [...Array(8)], //pieces can generate Hawk or Elephant?
      b: [...Array(8)]
    };
    const flags = fenflags.substr(4); //skip first 4 letters, for castle
    for (let c of ["w", "b"]) {
      for (let i = 0; i < 8; i++)
        this.pieceFlags[c][i] = flags.charAt((c == "w" ? 0 : 8) + i) == "1";
    }
  }

  aggregateFlags() {
    return [this.castleFlags, this.pieceFlags];
  }

  disaggregateFlags(flags) {
    this.castleFlags = flags[0];
    this.pieceFlags = flags[1];
  }

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

  static GenRandInitFen(randomness) {
    return (
      ChessRules.GenRandInitFen(randomness).slice(0, -2) +
      // Add pieceFlags + pocket
      "1111111111111111 - 1111"
    );
  }

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

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

  getFlagsFen() {
    let fen = super.getFlagsFen();
    // Add pieces flags
    for (let c of ["w", "b"])
      for (let i = 0; i < 8; i++) fen += (this.pieceFlags[c][i] ? "1" : "0");
    return fen;
  }

  getPocketFen() {
    let res = "";
    for (let c of ["w", "b"])
      res += this.pocket[c][V.HAWK] + this.pocket[c][V.ELEPHANT];
    return res;
  }

  setOtherVariables(fen) {
    super.setOtherVariables(fen);
    const fenParsed = V.ParseFen(fen);
    this.pocket = {
      "w": {
        h: parseInt(fenParsed.pocket[0], 10),
        e: parseInt(fenParsed.pocket[1], 10)
      },
      "b": {
        h: parseInt(fenParsed.pocket[2], 10),
        e: parseInt(fenParsed.pocket[3], 10)
      }
    };
  }

  getPotentialMovesFrom([x, y]) {
    let moves = undefined;
    switch (this.getPiece(x, y)) {
      case V.HAWK:
        moves = this.getPotentialHawkMoves([x, y]);
        break;
      case V.ELEPHANT:
        moves = this.getPotentialElephantMoves([x, y]);
        break;
      default:
        moves = super.getPotentialMovesFrom([x, y]);
    }
    // For moves presentation when choices:
    const unshiftNothing = (m) => {
      const a = m.appear[0];
      m.appear.unshift(new PiPo({
        p: V.NOTHING,
        c: 'o',
        x: a.x,
        y: a.y
      }));
    };
    // Post-processing: add choices for hawk and elephant,
    // except for moves letting the king under check.
    const color = this.turn;
    if (Object.values(this.pocket[color]).some(v => v > 0)) {
      const firstRank = (color == "w" ? 7 : 0);
      let validMoves = [];
      moves.forEach(m => {
        let inCheckAfter = false;
        this.play(m);
        if (this.underCheck(color)) inCheckAfter = true;
        this.undo(m);
        if (!inCheckAfter) {
          for (let pp of ['h', 'e']) {
            if (this.pocket[color][pp] > 0) {
              let shift = (m.appear[0].p == V.NOTHING ? 1 : 0);
              if (
                m.start.x == firstRank &&
                this.pieceFlags[color][m.start.y] &&
                (
                  m.appear.length == shift+1 ||
                  // Special castle case: is initial king square free?
                  ![m.appear[shift].y, m.appear[shift+1].y]
                    .includes(m.vanish[0].y)
                )
              ) {
                let pMove = JSON.parse(JSON.stringify(m));
                if (shift == 1) pMove.appear.shift();
                // NOTE: unshift instead of push, for choices presentation
                pMove.appear.unshift(new PiPo({
                  p: pp,
                  c: color,
                  x: x,
                  y: y
                }));
                validMoves.push(pMove);
                if (shift == 0) unshiftNothing(m);
              }
              shift = (m.appear[0].p == V.NOTHING ? 1 : 0);
              if (
                m.appear.length >= 2 + shift &&
                m.vanish.length == 2 &&
                ![m.appear[shift].y, m.appear[shift+1].y]
                  .includes(m.vanish[1].y)
              ) {
                // Special castle case: rook flag was necessarily on
                let pMove = JSON.parse(JSON.stringify(m));
                if (shift == 1) pMove.appear.shift();
                pMove.appear.unshift(new PiPo({
                  p: pp,
                  c: color,
                  x: m.vanish[1].x,
                  y: m.vanish[1].y
                }));
                validMoves.push(pMove);
                if (shift == 0) unshiftNothing(m);
              }
            }
          }
          // Unshift, to show the empty square on the left:
          validMoves.unshift(m);
        }
      });
      moves = validMoves;
    }
    return moves;
  }

  getPotentialHawkMoves(sq) {
    return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]).concat(
      this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
    );
  }

  getPotentialElephantMoves(sq) {
    return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat(
      this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
    );
  }

  isAttacked(sq, color) {
    return (
      super.isAttacked(sq, color) ||
      this.isAttackedByHawk(sq, color) ||
      this.isAttackedByElephant(sq, color)
    );
  }

  isAttackedByHawk(sq, color) {
    return (
      this.isAttackedBySlideNJump(sq, color, V.HAWK, V.steps[V.BISHOP]) ||
      this.isAttackedBySlideNJump(
        sq,
        color,
        V.HAWK,
        V.steps[V.KNIGHT],
        "oneStep"
      )
    );
  }

  isAttackedByElephant(sq, color) {
    return (
      this.isAttackedBySlideNJump(sq, color, V.ELEPHANT, V.steps[V.ROOK]) ||
      this.isAttackedBySlideNJump(
        sq,
        color,
        V.ELEPHANT,
        V.steps[V.KNIGHT],
        "oneStep"
      )
    );
  }

  filterValid(moves) {
    if (Object.values(this.pocket[this.turn]).some(v => v > 0))
      // Undercheck tests done in getPotentialMovesFrom()
      return moves;
    return super.filterValid(moves);
  }

  prePlay(move) {
    super.prePlay(move);
    if (move.appear.length >= 2) {
      if ([V.HAWK, V.ELEPHANT].includes(move.appear[0].p)) {
        // A pocket piece is used
        const color = this.turn;
        this.pocket[color][move.appear[0].p] = 0;
      }
    }
  }

  postPlay(move) {
    const color = move.vanish[0].c;
    const piece = move.vanish[0].p;
    // Update king position + flags
    if (piece == V.KING) {
      const shift =
        ([V.HAWK, V.ELEPHANT, V.NOTHING].includes(move.appear[0].p) ? 1 : 0);
      this.kingPos[color][0] = move.appear[shift].x;
      this.kingPos[color][1] = move.appear[shift].y;
    }
    this.updateCastleFlags(move, piece);

    const oppCol = this.turn;
    const firstRank = (color == 'w' ? 7 : 0);
    const oppFirstRank = 7 - firstRank;
    // Does this move turn off a piece init square flag?
    if (move.start.x == firstRank) {
      if (this.pieceFlags[color][move.start.y])
        this.pieceFlags[color][move.start.y] = false;
      // Special castle case:
      if (move.appear.length >= 2 && move.vanish.length == 2) {
        const L = move.appear.length;
        if (move.appear[L-1].p == V.ROOK)
          this.pieceFlags[color][move.vanish[1].y] = false;
      }
    }
    if (move.end.x == oppFirstRank && this.pieceFlags[oppCol][move.end.y])
      this.pieceFlags[oppCol][move.end.y] = false;
  }

  postUndo(move) {
    super.postUndo(move);
    if (move.appear.length >= 2) {
      if ([V.HAWK, V.ELEPHANT].includes(move.appear[0].p)) {
        // A pocket piece was used
        const color = this.turn;
        this.pocket[color][move.appear[0].p] = 1;
      }
    }
  }

  static get SEARCH_DEPTH() {
    return 2;
  }

  static get VALUES() {
    return Object.assign(
      {},
      ChessRules.VALUES,
      { 'h': 5, 'e': 7 }
    );
  }

  getNotation(move) {
    if (move.appear.length >= 2) {
      const pPieceAppear = [V.HAWK, V.ELEPHANT].includes(move.appear[0].p);
      const nothingAppear = (move.appear[0].p == V.NOTHING);
      if (pPieceAppear || nothingAppear) {
        let suffix = "";
        if (pPieceAppear) suffix = "/" + move.appear[0].p.toUpperCase();
        let cmove = JSON.parse(JSON.stringify(move));
        cmove.appear.shift();
        return super.getNotation(cmove) + suffix;
      }
    }
    return super.getNotation(move);
  }

};
Commit	Line	Data
305ede7e BA	1	import { ChessRules, PiPo } from "@/base_rules";
	2
	3	export class SchessRules extends ChessRules {
7e8a7ea1	4
305ede7e BA	5	static get PawnSpecs() {
	6	return Object.assign(
	7	{},
	8	ChessRules.PawnSpecs,
	9	{
	10	promotions:
	11	ChessRules.PawnSpecs.promotions.concat([V.HAWK, V.ELEPHANT])
	12	}
	13	);
	14	}
	15
	16	static get HAWK() {
	17	return 'h';
	18	}
	19
	20	static get ELEPHANT() {
	21	return 'e';
	22	}
	23
4ec83d37 BA	24	static get NOTHING() {
	25	return 'o';
	26	}
	27
305ede7e BA	28	static get PIECES() {
	29	return ChessRules.PIECES.concat([V.HAWK, V.ELEPHANT]);
	30	}
	31
	32	getPpath(b) {
4ec83d37	33	if ([V.HAWK, V.ELEPHANT, V.NOTHING].includes(b[1])) return "Schess/" + b;
305ede7e BA	34	return b;
	35	}
	36
305ede7e BA	37	static IsGoodFen(fen) {
	38	if (!ChessRules.IsGoodFen(fen)) return false;
	39	const fenParsed = V.ParseFen(fen);
	40	// Check pocket state
	41	if (!fenParsed.pocket \|\| !fenParsed.pocket.match(/^[0-1]{4,4}$/))
	42	return false;
	43	return true;
	44	}
	45
	46	static IsGoodFlags(flags) {
	47	// 4 for castle + 16 for generators
	48	return !!flags.match(/^[a-z]{4,4}[01]{16,16}$/);
	49	}
	50
	51	setFlags(fenflags) {
	52	super.setFlags(fenflags); //castleFlags
	53	this.pieceFlags = {
0d5335de	54	w: [...Array(8)], //pieces can generate Hawk or Elephant?
305ede7e BA	55	b: [...Array(8)]
	56	};
	57	const flags = fenflags.substr(4); //skip first 4 letters, for castle
	58	for (let c of ["w", "b"]) {
	59	for (let i = 0; i < 8; i++)
	60	this.pieceFlags[c][i] = flags.charAt((c == "w" ? 0 : 8) + i) == "1";
	61	}
	62	}
	63
	64	aggregateFlags() {
	65	return [this.castleFlags, this.pieceFlags];
	66	}
	67
	68	disaggregateFlags(flags) {
	69	this.castleFlags = flags[0];
	70	this.pieceFlags = flags[1];
	71	}
	72
	73	static ParseFen(fen) {
	74	const fenParts = fen.split(" ");
	75	return Object.assign(
	76	ChessRules.ParseFen(fen),
	77	{ pocket: fenParts[5] }
	78	);
	79	}
	80
	81	static GenRandInitFen(randomness) {
	82	return (
	83	ChessRules.GenRandInitFen(randomness).slice(0, -2) +
	84	// Add pieceFlags + pocket
	85	"1111111111111111 - 1111"
	86	);
	87	}
	88
	89	getFen() {
	90	return (
	91	super.getFen() + " " +
	92	this.getPocketFen()
	93	);
	94	}
	95
	96	getFenForRepeat() {
	97	return (
	98	super.getFenForRepeat() + "_" +
	99	this.getPocketFen()
	100	);
	101	}
	102
	103	getFlagsFen() {
	104	let fen = super.getFlagsFen();
	105	// Add pieces flags
	106	for (let c of ["w", "b"])
	107	for (let i = 0; i < 8; i++) fen += (this.pieceFlags[c][i] ? "1" : "0");
	108	return fen;
	109	}
	110
	111	getPocketFen() {
	112	let res = "";
	113	for (let c of ["w", "b"])
	114	res += this.pocket[c][V.HAWK] + this.pocket[c][V.ELEPHANT];
	115	return res;
	116	}
	117
	118	setOtherVariables(fen) {
119	super.setOtherVariables(fen);
120	const fenParsed = V.ParseFen(fen);
121	this.pocket = {
122	"w": {
e50a8025 BA	123	h: parseInt(fenParsed.pocket[0], 10),
e50a8025 BA	124	e: parseInt(fenParsed.pocket[1], 10)
305ede7e BA	125	},
305ede7e BA	126	"b": {
e50a8025 BA	127	h: parseInt(fenParsed.pocket[2], 10),
e50a8025 BA	128	e: parseInt(fenParsed.pocket[3], 10)
305ede7e BA	129	}
	130	};
	131	}
	132
	133	getPotentialMovesFrom([x, y]) {
	134	let moves = undefined;
	135	switch (this.getPiece(x, y)) {
	136	case V.HAWK:
	137	moves = this.getPotentialHawkMoves([x, y]);
	138	break;
	139	case V.ELEPHANT:
	140	moves = this.getPotentialElephantMoves([x, y]);
	141	break;
	142	default:
	143	moves = super.getPotentialMovesFrom([x, y]);
	144	}
4ec83d37 BA	145	// For moves presentation when choices:
	146	const unshiftNothing = (m) => {
	147	const a = m.appear[0];
	148	m.appear.unshift(new PiPo({
	149	p: V.NOTHING,
	150	c: 'o',
	151	x: a.x,
	152	y: a.y
	153	}));
	154	};
305ede7e BA	155	// Post-processing: add choices for hawk and elephant,
	156	// except for moves letting the king under check.
	157	const color = this.turn;
	158	if (Object.values(this.pocket[color]).some(v => v > 0)) {
	159	const firstRank = (color == "w" ? 7 : 0);
4ec83d37	160	let validMoves = [];
305ede7e BA	161	moves.forEach(m => {
	162	let inCheckAfter = false;
	163	this.play(m);
	164	if (this.underCheck(color)) inCheckAfter = true;
	165	this.undo(m);
	166	if (!inCheckAfter) {
	167	for (let pp of ['h', 'e']) {
	168	if (this.pocket[color][pp] > 0) {
4ec83d37	169	let shift = (m.appear[0].p == V.NOTHING ? 1 : 0);
305ede7e BA	170	if (
	171	m.start.x == firstRank &&
	172	this.pieceFlags[color][m.start.y] &&
	173	(
4ec83d37	174	m.appear.length == shift+1 \|\|
305ede7e	175	// Special castle case: is initial king square free?
2c5d7b20 BA	176	![m.appear[shift].y, m.appear[shift+1].y]
2c5d7b20 BA	177	.includes(m.vanish[0].y)
305ede7e BA	178	)
	179	) {
	180	let pMove = JSON.parse(JSON.stringify(m));
4ec83d37	181	if (shift == 1) pMove.appear.shift();
305ede7e BA	182	// NOTE: unshift instead of push, for choices presentation
	183	pMove.appear.unshift(new PiPo({
	184	p: pp,
	185	c: color,
	186	x: x,
	187	y: y
	188	}));
4ec83d37 BA	189	validMoves.push(pMove);
4ec83d37 BA	190	if (shift == 0) unshiftNothing(m);
305ede7e	191	}
4ec83d37	192	shift = (m.appear[0].p == V.NOTHING ? 1 : 0);
305ede7e	193	if (
58bf4670	194	m.appear.length >= 2 + shift &&
4ec83d37	195	m.vanish.length == 2 &&
2c5d7b20 BA	196	![m.appear[shift].y, m.appear[shift+1].y]
2c5d7b20 BA	197	.includes(m.vanish[1].y)
305ede7e BA	198	) {
	199	// Special castle case: rook flag was necessarily on
	200	let pMove = JSON.parse(JSON.stringify(m));
4ec83d37	201	if (shift == 1) pMove.appear.shift();
305ede7e BA	202	pMove.appear.unshift(new PiPo({
	203	p: pp,
	204	c: color,
	205	x: m.vanish[1].x,
	206	y: m.vanish[1].y
	207	}));
4ec83d37 BA	208	validMoves.push(pMove);
4ec83d37 BA	209	if (shift == 0) unshiftNothing(m);
305ede7e BA	210	}
	211	}
	212	}
4ec83d37 BA	213	// Unshift, to show the empty square on the left:
4ec83d37 BA	214	validMoves.unshift(m);
305ede7e BA	215	}
305ede7e BA	216	});
4ec83d37	217	moves = validMoves;
305ede7e BA	218	}
	219	return moves;
	220	}
	221
	222	getPotentialHawkMoves(sq) {
40ac07d9 BA	223	return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP]).concat(
40ac07d9 BA	224	this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
305ede7e BA	225	);
	226	}
	227
	228	getPotentialElephantMoves(sq) {
40ac07d9 BA	229	return this.getSlideNJumpMoves(sq, V.steps[V.ROOK]).concat(
40ac07d9 BA	230	this.getSlideNJumpMoves(sq, V.steps[V.KNIGHT], "oneStep")
305ede7e BA	231	);
	232	}
	233
	234	isAttacked(sq, color) {
	235	return (
	236	super.isAttacked(sq, color) \|\|
	237	this.isAttackedByHawk(sq, color) \|\|
	238	this.isAttackedByElephant(sq, color)
	239	);
	240	}
	241
	242	isAttackedByHawk(sq, color) {
40ac07d9 BA	243	return (
	244	this.isAttackedBySlideNJump(sq, color, V.HAWK, V.steps[V.BISHOP]) \|\|
	245	this.isAttackedBySlideNJump(
	246	sq,
	247	color,
	248	V.HAWK,
	249	V.steps[V.KNIGHT],
	250	"oneStep"
	251	)
305ede7e BA	252	);
	253	}
	254
	255	isAttackedByElephant(sq, color) {
40ac07d9 BA	256	return (
	257	this.isAttackedBySlideNJump(sq, color, V.ELEPHANT, V.steps[V.ROOK]) \|\|
	258	this.isAttackedBySlideNJump(
	259	sq,
	260	color,
	261	V.ELEPHANT,
	262	V.steps[V.KNIGHT],
	263	"oneStep"
	264	)
305ede7e BA	265	);
	266	}
	267
4ec83d37 BA	268	filterValid(moves) {
	269	if (Object.values(this.pocket[this.turn]).some(v => v > 0))
	270	// Undercheck tests done in getPotentialMovesFrom()
	271	return moves;
	272	return super.filterValid(moves);
	273	}
	274
305ede7e BA	275	prePlay(move) {
	276	super.prePlay(move);
	277	if (move.appear.length >= 2) {
	278	if ([V.HAWK, V.ELEPHANT].includes(move.appear[0].p)) {
	279	// A pocket piece is used
	280	const color = this.turn;
	281	this.pocket[color][move.appear[0].p] = 0;
	282	}
	283	}
	284	}
	285
	286	postPlay(move) {
305ede7e	287	const color = move.vanish[0].c;
4ec83d37 BA	288	const piece = move.vanish[0].p;
	289	// Update king position + flags
	290	if (piece == V.KING) {
	291	const shift =
	292	([V.HAWK, V.ELEPHANT, V.NOTHING].includes(move.appear[0].p) ? 1 : 0);
	293	this.kingPos[color][0] = move.appear[shift].x;
	294	this.kingPos[color][1] = move.appear[shift].y;
4ec83d37 BA	295	}
	296	this.updateCastleFlags(move, piece);
	297
0d5335de	298	const oppCol = this.turn;
305ede7e BA	299	const firstRank = (color == 'w' ? 7 : 0);
	300	const oppFirstRank = 7 - firstRank;
	301	// Does this move turn off a piece init square flag?
	302	if (move.start.x == firstRank) {
	303	if (this.pieceFlags[color][move.start.y])
	304	this.pieceFlags[color][move.start.y] = false;
	305	// Special castle case:
4ec83d37	306	if (move.appear.length >= 2 && move.vanish.length == 2) {
305ede7e BA	307	const L = move.appear.length;
	308	if (move.appear[L-1].p == V.ROOK)
	309	this.pieceFlags[color][move.vanish[1].y] = false;
	310	}
	311	}
	312	if (move.end.x == oppFirstRank && this.pieceFlags[oppCol][move.end.y])
	313	this.pieceFlags[oppCol][move.end.y] = false;
	314	}
	315
	316	postUndo(move) {
	317	super.postUndo(move);
	318	if (move.appear.length >= 2) {
	319	if ([V.HAWK, V.ELEPHANT].includes(move.appear[0].p)) {
	320	// A pocket piece was used
	321	const color = this.turn;
	322	this.pocket[color][move.appear[0].p] = 1;
	323	}
	324	}
	325	}
	326
	327	static get SEARCH_DEPTH() {
	328	return 2;
	329	}
	330
	331	static get VALUES() {
	332	return Object.assign(
	333	{},
	334	ChessRules.VALUES,
	335	{ 'h': 5, 'e': 7 }
	336	);
	337	}
	338
	339	getNotation(move) {
4ec83d37 BA	340	if (move.appear.length >= 2) {
	341	const pPieceAppear = [V.HAWK, V.ELEPHANT].includes(move.appear[0].p);
	342	const nothingAppear = (move.appear[0].p == V.NOTHING);
	343	if (pPieceAppear \|\| nothingAppear) {
	344	let suffix = "";
	345	if (pPieceAppear) suffix = "/" + move.appear[0].p.toUpperCase();
	346	let cmove = JSON.parse(JSON.stringify(move));
	347	cmove.appear.shift();
	348	return super.getNotation(cmove) + suffix;
	349	}
305ede7e BA	350	}
	351	return super.getNotation(move);
	352	}
7e8a7ea1	353
305ede7e	354	};