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

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

export class SittuyinRules extends ChessRules {

  static get Options() {
    return null;
  }

  static get HasFlags() {
    return false;
  }

  static get HasEnpassant() {
    return false;
  }

  static get Monochrome() {
    return true;
  }

  static get Notoodark() {
    return true;
  }

  static get Lines() {
    return ChessRules.Lines.concat([
      [[0, 0], [8, 8]],
      [[0, 8], [8, 0]]
    ]);
  }

  static get PawnSpecs() {
    return Object.assign(
      {},
      ChessRules.PawnSpecs,
      {
        // Promotions are handled differently here
        promotions: [V.QUEEN]
      }
    );
  }

  static GenRandInitFen() {
    return "8/8/4pppp/pppp4/4PPPP/PPPP4/8/8 w 0";
  }

  re_setReserve(subTurn) {
    const mc = this.movesCount;
    const wc = (mc == 0 ? 1 : 0);
    const bc = (mc <= 1 ? 1 : 0);
    this.reserve = {
      w: {
        [V.ROOK]: wc * 2,
        [V.KNIGHT]: wc * 2,
        [V.BISHOP]: wc * 2,
        [V.QUEEN]: wc,
        [V.KING]: wc
      },
      b: {
        [V.ROOK]: bc * 2,
        [V.KNIGHT]: bc * 2,
        [V.BISHOP]: bc * 2,
        [V.QUEEN]: bc,
        [V.KING]: bc
      }
    }
    this.subTurn = subTurn || 1;
  }

  setOtherVariables(fen) {
    super.setOtherVariables(fen);
    if (this.movesCount <= 1) this.re_setReserve();
  }

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

  getColor(i, j) {
    if (i >= V.size.x) return i == V.size.x ? "w" : "b";
    return this.board[i][j].charAt(0);
  }

  getPiece(i, j) {
    if (i >= V.size.x) return V.RESERVE_PIECES[j];
    return this.board[i][j].charAt(1);
  }

  getReservePpath(index, color) {
    return "Sittuyin/" + color + V.RESERVE_PIECES[index];
  }

  static get RESERVE_PIECES() {
    return [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN, V.KING];
  }

  getPotentialMovesFrom([x, y]) {
    if (this.movesCount >= 2) return super.getPotentialMovesFrom([x, y]);
    // Only reserve moves are allowed for now:
    if (V.OnBoard(x, y)) return [];
    const color = this.turn;
    const p = V.RESERVE_PIECES[y];
    if (this.reserve[color][p] == 0) return [];
    const iBound =
      p != V.ROOK
        ? (color == 'w' ? [4, 7] : [0, 3])
        : (color == 'w' ? [7, 7] : [0, 0]);
    const jBound = (i) => {
      if (color == 'w' && i == 4) return [4, 7];
      if (color == 'b' && i == 3) return [0, 3];
      return [0, 7];
    };
    let moves = [];
    for (let i = iBound[0]; i <= iBound[1]; i++) {
      const jb = jBound(i);
      for (let j = jb[0]; j <= jb[1]; j++) {
        if (this.board[i][j] == V.EMPTY) {
          let mv = new Move({
            appear: [
              new PiPo({
                x: i,
                y: j,
                c: color,
                p: p
              })
            ],
            vanish: [],
            start: { x: x, y: y },
            end: { x: i, y: j }
          });
          moves.push(mv);
        }
      }
    }
    return moves;
  }

  getPotentialPawnMoves([x, y]) {
    const color = this.turn;
    const shiftX = V.PawnSpecs.directions[color];
    let moves = [];
    if (x + shiftX >= 0 && x + shiftX < 8) {
      if (this.board[x + shiftX][y] == V.EMPTY)
        // One square forward
        moves.push(this.getBasicMove([x, y], [x + shiftX, y]));
      // Captures
      for (let shiftY of [-1, 1]) {
        if (
          y + shiftY >= 0 && y + shiftY < 8 &&
          this.board[x + shiftX][y + shiftY] != V.EMPTY &&
          this.canTake([x, y], [x + shiftX, y + shiftY])
        ) {
          moves.push(this.getBasicMove([x, y], [x + shiftX, y + shiftY]));
        }
      }
    }
    let queenOnBoard = false;
    let pawnsCount = 0;
    outerLoop: for (let i=0; i<8; i++) {
      for (let j=0; j<8; j++) {
        if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) {
          const p = this.getPiece(i, j);
          if (p == V.QUEEN) {
            queenOnBoard = true;
            break outerLoop;
          }
          else if (p == V.PAWN && pawnsCount <= 1) pawnsCount++;
        }
      }
    }
    if (
      !queenOnBoard &&
      (
        pawnsCount == 1 ||
        (color == 'w' && ((y <= 3 && x == y) || (y >= 4 && x == 7 - y))) ||
        (color == 'b' && ((y >= 4 && x == y) || (y <= 3 && x == 7 - y)))
      )
    ) {
      const addPromotion = ([xx, yy], moveTo) => {
        // The promoted pawn shouldn't attack anything,
        // and the promotion shouldn't discover a rook attack on anything.
        const finalSquare = (!moveTo ? [x, y] : [xx, yy]);
        let validP = true;
        for (let step of V.steps[V.BISHOP]) {
          const [i, j] = [finalSquare[0] + step[0], finalSquare[1] + step[1]];
          if (
            V.OnBoard(i, j) &&
            this.board[i][j] != V.EMPTY &&
            this.getColor(i, j) != color
          ) {
            validP = false;
            break;
          }
        }
        if (validP && !!moveTo) {
          // Also check rook discovered attacks on the enemy king
          let found = {
            "0,-1": 0,
            "0,1": 0,
            "1,0": 0,
            "-1,0": 0
          };
          // TODO: check opposite steps one after another, which could
          // save some time (no need to explore the other line).
          for (let step of V.steps[V.ROOK]) {
            let [i, j] = [x + step[0], y + step[1]];
            while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
              i += step[0];
              j += step[1];
            }
            if (V.OnBoard(i, j)) {
              const colIJ = this.getColor(i, j);
              const pieceIJ = this.getPiece(i, j);
              if (colIJ != color && pieceIJ == V.KING)
                found[step[0] + "," + step[1]] = -1;
              else if (colIJ == color && pieceIJ == V.ROOK)
                found[step[0] + "," + step[1]] = 1;
            }
          }
          if (
            (found["0,-1"] * found["0,1"] < 0) ||
            (found["-1,0"] * found["1,0"] < 0)
          ) {
            validP = false;
          }
        }
        if (validP) {
          moves.push(
            new Move({
              appear: [
                new PiPo({
                  x: !!moveTo ? xx : x,
                  y: yy, //yy == y if !!moveTo
                  c: color,
                  p: V.QUEEN
                })
              ],
              vanish: [
                new PiPo({
                  x: x,
                  y: y,
                  c: color,
                  p: V.PAWN
                })
              ],
              start: { x: x, y: y },
              end: { x: xx, y: yy }
            })
          );
        }
      };
      // In-place promotion always possible:
      addPromotion([x - shiftX, y]);
      for (let step of V.steps[V.BISHOP]) {
        const [i, j] = [x + step[0], y + step[1]];
        if (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY)
          addPromotion([i, j], "moveTo");
      }
    }
    return moves;
  }

  getPotentialBishopMoves(sq) {
    const forward = (this.turn == 'w' ? -1 : 1);
    return this.getSlideNJumpMoves(
      sq, V.steps[V.BISHOP].concat([ [forward, 0] ]), 1);
  }

  getPotentialQueenMoves(sq) {
    return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP], 1);
  }

  getAllValidMoves() {
    if (this.movesCount >= 2) return super.getAllValidMoves();
    const color = this.turn;
    let moves = [];
    for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
      moves = moves.concat(
        this.getPotentialMovesFrom([V.size.x + (color == "w" ? 0 : 1), i])
      );
    }
    return this.filterValid(moves);
  }

  isAttackedByBishop(sq, color) {
    const forward = (this.turn == 'w' ? 1 : -1);
    return this.isAttackedBySlideNJump(
      sq, color, V.BISHOP, V.steps[V.BISHOP].concat([ [forward, 0] ]), 1);
  }

  isAttackedByQueen(sq, color) {
    return this.isAttackedBySlideNJump(
      sq, color, V.QUEEN, V.steps[V.BISHOP], 1);
  }

  underCheck(color) {
    if (this.movesCount <= 1) return false;
    return super.underCheck(color);
  }

  play(move) {
    const color = move.appear[0].c;
    if (this.movesCount <= 1) {
      V.PlayOnBoard(this.board, move);
      const piece = move.appear[0].p;
      this.reserve[color][piece]--;
      if (piece == V.KING) this.kingPos[color] = [move.end.x, move.end.y];
      if (this.subTurn == 8) {
        // All placement moves are done
        this.movesCount++;
        this.turn = V.GetOppCol(color);
        if (this.movesCount == 1) this.subTurn = 1;
        else {
          // Initial placement is over
          delete this["reserve"];
          delete this["subTurn"];
        }
      }
      else this.subTurn++;
    }
    else super.play(move);
  }

  undo(move) {
    const color = move.appear[0].c;
    if (this.movesCount <= 2) {
      V.UndoOnBoard(this.board, move);
      const piece = move.appear[0].p;
      if (piece == V.KING) this.kingPos[color] = [-1, -1];
      if (!this.subTurn || this.subTurn == 1) {
        // All placement moves are undone (if any)
        if (!this.subTurn) this.re_setReserve(8);
        else this.subTurn = 8;
        this.movesCount--;
        this.turn = color;
      }
      else this.subTurn--;
      this.reserve[color][piece]++;
    }
    else super.undo(move);
  }

  getCheckSquares() {
    if (this.movesCount <= 1) return [];
    return super.getCheckSquares();
  }

  getCurrentScore() {
    if (this.movesCount <= 1) return "*";
    return super.getCurrentScore();
  }

  static get VALUES() {
    return {
      p: 1,
      r: 5,
      n: 3,
      b: 3,
      q: 2,
      k: 1000
    };
  }

  getComputerMove() {
    if (this.movesCount >= 2) return super.getComputerMove();
    // Play a random "initialization move"
    let res = [];
    for (let i=0; i<8; i++) {
      const moves = this.getAllValidMoves();
      const moveIdx = randInt(moves.length);
      this.play(moves[moveIdx]);
      res.push(moves[moveIdx]);
    }
    for (let i=7; i>=0; i--) this.undo(res[i]);
    return res;
  }

  getNotation(move) {
    // Do not note placement moves (complete move would be too long)
    if (move.vanish.length == 0) return "";
    if (move.appear[0].p != move.vanish[0].p) {
      // Pawn promotion: indicate correct final square
      const initSquare =
        V.CoordsToSquare({ x: move.vanish[0].x, y: move.vanish[0].y })
      const destSquare =
        V.CoordsToSquare({ x: move.appear[0].x, y: move.appear[0].y })
      const prefix = (initSquare != destSquare ? initSquare : "");
      return prefix + destSquare + "=Q";
    }
    return super.getNotation(move);
  }

};
Commit	Line	Data
	1	import { ChessRules, Move, PiPo } from "@/base_rules";
	2	import { randInt } from "@/utils/alea";
	3
	4	export class SittuyinRules extends ChessRules {
	5
	6	static get Options() {
	7	return null;
	8	}
	9
	10	static get HasFlags() {
	11	return false;
	12	}
	13
	14	static get HasEnpassant() {
	15	return false;
	16	}
	17
	18	static get Monochrome() {
	19	return true;
	20	}
	21
	22	static get Notoodark() {
	23	return true;
	24	}
	25
	26	static get Lines() {
	27	return ChessRules.Lines.concat([
	28	[[0, 0], [8, 8]],
	29	[[0, 8], [8, 0]]
	30	]);
	31	}
	32
	33	static get PawnSpecs() {
	34	return Object.assign(
	35	{},
	36	ChessRules.PawnSpecs,
	37	{
	38	// Promotions are handled differently here
	39	promotions: [V.QUEEN]
	40	}
	41	);
	42	}
	43
	44	static GenRandInitFen() {
	45	return "8/8/4pppp/pppp4/4PPPP/PPPP4/8/8 w 0";
	46	}
	47
	48	re_setReserve(subTurn) {
	49	const mc = this.movesCount;
	50	const wc = (mc == 0 ? 1 : 0);
	51	const bc = (mc <= 1 ? 1 : 0);
	52	this.reserve = {
	53	w: {
	54	[V.ROOK]: wc * 2,
	55	[V.KNIGHT]: wc * 2,
	56	[V.BISHOP]: wc * 2,
	57	[V.QUEEN]: wc,
	58	[V.KING]: wc
	59	},
	60	b: {
	61	[V.ROOK]: bc * 2,
	62	[V.KNIGHT]: bc * 2,
	63	[V.BISHOP]: bc * 2,
	64	[V.QUEEN]: bc,
	65	[V.KING]: bc
	66	}
	67	}
	68	this.subTurn = subTurn \|\| 1;
	69	}
	70
	71	setOtherVariables(fen) {
	72	super.setOtherVariables(fen);
	73	if (this.movesCount <= 1) this.re_setReserve();
	74	}
	75
	76	getPpath(b) {
	77	return "Sittuyin/" + b;
	78	}
	79
	80	getColor(i, j) {
	81	if (i >= V.size.x) return i == V.size.x ? "w" : "b";
	82	return this.board[i][j].charAt(0);
	83	}
	84
	85	getPiece(i, j) {
	86	if (i >= V.size.x) return V.RESERVE_PIECES[j];
	87	return this.board[i][j].charAt(1);
	88	}
	89
	90	getReservePpath(index, color) {
	91	return "Sittuyin/" + color + V.RESERVE_PIECES[index];
	92	}
	93
	94	static get RESERVE_PIECES() {
	95	return [V.ROOK, V.KNIGHT, V.BISHOP, V.QUEEN, V.KING];
	96	}
	97
	98	getPotentialMovesFrom([x, y]) {
	99	if (this.movesCount >= 2) return super.getPotentialMovesFrom([x, y]);
	100	// Only reserve moves are allowed for now:
	101	if (V.OnBoard(x, y)) return [];
	102	const color = this.turn;
	103	const p = V.RESERVE_PIECES[y];
	104	if (this.reserve[color][p] == 0) return [];
	105	const iBound =
	106	p != V.ROOK
	107	? (color == 'w' ? [4, 7] : [0, 3])
	108	: (color == 'w' ? [7, 7] : [0, 0]);
	109	const jBound = (i) => {
	110	if (color == 'w' && i == 4) return [4, 7];
	111	if (color == 'b' && i == 3) return [0, 3];
	112	return [0, 7];
	113	};
	114	let moves = [];
	115	for (let i = iBound[0]; i <= iBound[1]; i++) {
	116	const jb = jBound(i);
	117	for (let j = jb[0]; j <= jb[1]; j++) {
	118	if (this.board[i][j] == V.EMPTY) {
	119	let mv = new Move({
	120	appear: [
	121	new PiPo({
	122	x: i,
	123	y: j,
	124	c: color,
	125	p: p
	126	})
	127	],
	128	vanish: [],
	129	start: { x: x, y: y },
	130	end: { x: i, y: j }
	131	});
	132	moves.push(mv);
	133	}
	134	}
	135	}
	136	return moves;
	137	}
	138
	139	getPotentialPawnMoves([x, y]) {
	140	const color = this.turn;
	141	const shiftX = V.PawnSpecs.directions[color];
	142	let moves = [];
	143	if (x + shiftX >= 0 && x + shiftX < 8) {
	144	if (this.board[x + shiftX][y] == V.EMPTY)
	145	// One square forward
	146	moves.push(this.getBasicMove([x, y], [x + shiftX, y]));
	147	// Captures
	148	for (let shiftY of [-1, 1]) {
	149	if (
	150	y + shiftY >= 0 && y + shiftY < 8 &&
	151	this.board[x + shiftX][y + shiftY] != V.EMPTY &&
	152	this.canTake([x, y], [x + shiftX, y + shiftY])
	153	) {
	154	moves.push(this.getBasicMove([x, y], [x + shiftX, y + shiftY]));
	155	}
	156	}
	157	}
	158	let queenOnBoard = false;
	159	let pawnsCount = 0;
	160	outerLoop: for (let i=0; i<8; i++) {
	161	for (let j=0; j<8; j++) {
	162	if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color) {
	163	const p = this.getPiece(i, j);
	164	if (p == V.QUEEN) {
	165	queenOnBoard = true;
	166	break outerLoop;
	167	}
	168	else if (p == V.PAWN && pawnsCount <= 1) pawnsCount++;
	169	}
	170	}
	171	}
	172	if (
	173	!queenOnBoard &&
	174	(
	175	pawnsCount == 1 \|\|
	176	(color == 'w' && ((y <= 3 && x == y) \|\| (y >= 4 && x == 7 - y))) \|\|
	177	(color == 'b' && ((y >= 4 && x == y) \|\| (y <= 3 && x == 7 - y)))
	178	)
	179	) {
	180	const addPromotion = ([xx, yy], moveTo) => {
	181	// The promoted pawn shouldn't attack anything,
	182	// and the promotion shouldn't discover a rook attack on anything.
	183	const finalSquare = (!moveTo ? [x, y] : [xx, yy]);
	184	let validP = true;
	185	for (let step of V.steps[V.BISHOP]) {
	186	const [i, j] = [finalSquare[0] + step[0], finalSquare[1] + step[1]];
	187	if (
	188	V.OnBoard(i, j) &&
	189	this.board[i][j] != V.EMPTY &&
	190	this.getColor(i, j) != color
	191	) {
	192	validP = false;
	193	break;
	194	}
	195	}
	196	if (validP && !!moveTo) {
	197	// Also check rook discovered attacks on the enemy king
	198	let found = {
	199	"0,-1": 0,
	200	"0,1": 0,
	201	"1,0": 0,
	202	"-1,0": 0
	203	};
	204	// TODO: check opposite steps one after another, which could
	205	// save some time (no need to explore the other line).
	206	for (let step of V.steps[V.ROOK]) {
	207	let [i, j] = [x + step[0], y + step[1]];
	208	while (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY) {
	209	i += step[0];
	210	j += step[1];
	211	}
	212	if (V.OnBoard(i, j)) {
	213	const colIJ = this.getColor(i, j);
	214	const pieceIJ = this.getPiece(i, j);
	215	if (colIJ != color && pieceIJ == V.KING)
	216	found[step[0] + "," + step[1]] = -1;
	217	else if (colIJ == color && pieceIJ == V.ROOK)
	218	found[step[0] + "," + step[1]] = 1;
	219	}
	220	}
	221	if (
	222	(found["0,-1"] * found["0,1"] < 0) \|\|
	223	(found["-1,0"] * found["1,0"] < 0)
	224	) {
	225	validP = false;
	226	}
	227	}
	228	if (validP) {
	229	moves.push(
	230	new Move({
	231	appear: [
	232	new PiPo({
	233	x: !!moveTo ? xx : x,
	234	y: yy, //yy == y if !!moveTo
	235	c: color,
	236	p: V.QUEEN
	237	})
	238	],
	239	vanish: [
	240	new PiPo({
	241	x: x,
	242	y: y,
	243	c: color,
	244	p: V.PAWN
	245	})
	246	],
	247	start: { x: x, y: y },
	248	end: { x: xx, y: yy }
	249	})
	250	);
	251	}
	252	};
	253	// In-place promotion always possible:
	254	addPromotion([x - shiftX, y]);
	255	for (let step of V.steps[V.BISHOP]) {
	256	const [i, j] = [x + step[0], y + step[1]];
	257	if (V.OnBoard(i, j) && this.board[i][j] == V.EMPTY)
	258	addPromotion([i, j], "moveTo");
	259	}
	260	}
	261	return moves;
	262	}
	263
	264	getPotentialBishopMoves(sq) {
	265	const forward = (this.turn == 'w' ? -1 : 1);
	266	return this.getSlideNJumpMoves(
	267	sq, V.steps[V.BISHOP].concat([ [forward, 0] ]), 1);
	268	}
	269
	270	getPotentialQueenMoves(sq) {
	271	return this.getSlideNJumpMoves(sq, V.steps[V.BISHOP], 1);
	272	}
	273
	274	getAllValidMoves() {
	275	if (this.movesCount >= 2) return super.getAllValidMoves();
	276	const color = this.turn;
	277	let moves = [];
	278	for (let i = 0; i < V.RESERVE_PIECES.length; i++) {
	279	moves = moves.concat(
	280	this.getPotentialMovesFrom([V.size.x + (color == "w" ? 0 : 1), i])
	281	);
	282	}
	283	return this.filterValid(moves);
	284	}
	285
	286	isAttackedByBishop(sq, color) {
	287	const forward = (this.turn == 'w' ? 1 : -1);
	288	return this.isAttackedBySlideNJump(
	289	sq, color, V.BISHOP, V.steps[V.BISHOP].concat([ [forward, 0] ]), 1);
	290	}
	291
	292	isAttackedByQueen(sq, color) {
	293	return this.isAttackedBySlideNJump(
	294	sq, color, V.QUEEN, V.steps[V.BISHOP], 1);
	295	}
	296
	297	underCheck(color) {
	298	if (this.movesCount <= 1) return false;
	299	return super.underCheck(color);
	300	}
	301
	302	play(move) {
	303	const color = move.appear[0].c;
	304	if (this.movesCount <= 1) {
	305	V.PlayOnBoard(this.board, move);
	306	const piece = move.appear[0].p;
	307	this.reserve[color][piece]--;
	308	if (piece == V.KING) this.kingPos[color] = [move.end.x, move.end.y];
	309	if (this.subTurn == 8) {
	310	// All placement moves are done
	311	this.movesCount++;
	312	this.turn = V.GetOppCol(color);
	313	if (this.movesCount == 1) this.subTurn = 1;
	314	else {
	315	// Initial placement is over
	316	delete this["reserve"];
	317	delete this["subTurn"];
	318	}
	319	}
	320	else this.subTurn++;
	321	}
	322	else super.play(move);
	323	}
	324
	325	undo(move) {
	326	const color = move.appear[0].c;
	327	if (this.movesCount <= 2) {
	328	V.UndoOnBoard(this.board, move);
	329	const piece = move.appear[0].p;
	330	if (piece == V.KING) this.kingPos[color] = [-1, -1];
	331	if (!this.subTurn \|\| this.subTurn == 1) {
	332	// All placement moves are undone (if any)
	333	if (!this.subTurn) this.re_setReserve(8);
	334	else this.subTurn = 8;
	335	this.movesCount--;
	336	this.turn = color;
	337	}
	338	else this.subTurn--;
	339	this.reserve[color][piece]++;
	340	}
	341	else super.undo(move);
	342	}
	343
	344	getCheckSquares() {
	345	if (this.movesCount <= 1) return [];
	346	return super.getCheckSquares();
	347	}
	348
	349	getCurrentScore() {
	350	if (this.movesCount <= 1) return "*";
	351	return super.getCurrentScore();
	352	}
	353
	354	static get VALUES() {
	355	return {
	356	p: 1,
	357	r: 5,
	358	n: 3,
	359	b: 3,
	360	q: 2,
	361	k: 1000
	362	};
	363	}
	364
	365	getComputerMove() {
	366	if (this.movesCount >= 2) return super.getComputerMove();
	367	// Play a random "initialization move"
	368	let res = [];
	369	for (let i=0; i<8; i++) {
	370	const moves = this.getAllValidMoves();
	371	const moveIdx = randInt(moves.length);
	372	this.play(moves[moveIdx]);
	373	res.push(moves[moveIdx]);
	374	}
	375	for (let i=7; i>=0; i--) this.undo(res[i]);
	376	return res;
	377	}
	378
	379	getNotation(move) {
	380	// Do not note placement moves (complete move would be too long)
	381	if (move.vanish.length == 0) return "";
	382	if (move.appear[0].p != move.vanish[0].p) {
	383	// Pawn promotion: indicate correct final square
	384	const initSquare =
	385	V.CoordsToSquare({ x: move.vanish[0].x, y: move.vanish[0].y })
	386	const destSquare =
	387	V.CoordsToSquare({ x: move.appear[0].x, y: move.appear[0].y })
	388	const prefix = (initSquare != destSquare ? initSquare : "");
	389	return prefix + destSquare + "=Q";
	390	}
	391	return super.getNotation(move);
	392	}
	393
	394	};