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

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

export class WildebeestRules extends ChessRules {

  static get size() {
    return { x: 10, y: 11 };
  }

  static get CAMEL() {
    return "c";
  }
  static get WILDEBEEST() {
    return "w";
  }

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

  static get steps() {
    return Object.assign(
      {},
      ChessRules.steps,
      // Add camel moves:
      {
        c: [
          [-3, -1],
          [-3, 1],
          [-1, -3],
          [-1, 3],
          [1, -3],
          [1, 3],
          [3, -1],
          [3, 1]
        ]
      }
    );
  }

  static IsGoodEnpassant(enpassant) {
    if (enpassant != "-") return !!enpassant.match(/^([a-j][0-9]{1,2},?)+$/);
    return true;
  }

  getPpath(b) {
    return ([V.CAMEL, V.WILDEBEEST].includes(b[1]) ? "Wildebeest/" : "") + b;
  }

  // There may be 2 enPassant squares (if pawn jump 3 squares)
  getEnpassantFen() {
    const L = this.epSquares.length;
    if (!this.epSquares[L - 1]) return "-"; //no en-passant
    let res = "";
    this.epSquares[L - 1].forEach(sq => {
      res += V.CoordsToSquare(sq) + ",";
    });
    return res.slice(0, -1); //remove last comma
  }

  // En-passant after 2-sq or 3-sq jumps
  getEpSquare(moveOrSquare) {
    if (!moveOrSquare) return undefined;
    if (typeof moveOrSquare === "string") {
      const square = moveOrSquare;
      if (square == "-") return undefined;
      let res = [];
      square.split(",").forEach(sq => {
        res.push(V.SquareToCoords(sq));
      });
      return res;
    }
    // Argument is a move:
    const move = moveOrSquare;
    const [sx, sy, ex] = [move.start.x, move.start.y, move.end.x];
    if (this.getPiece(sx, sy) == V.PAWN && Math.abs(sx - ex) >= 2) {
      const step = (ex - sx) / Math.abs(ex - sx);
      let res = [
        {
          x: sx + step,
          y: sy
        }
      ];
      if (sx + 2 * step != ex) {
        // 3-squares move
        res.push({
          x: sx + 2 * step,
          y: sy
        });
      }
      return res;
    }
    return undefined; //default
  }

  getPotentialMovesFrom([x, y]) {
    switch (this.getPiece(x, y)) {
      case V.CAMEL:
        return this.getPotentialCamelMoves([x, y]);
      case V.WILDEBEEST:
        return this.getPotentialWildebeestMoves([x, y]);
      default:
        return super.getPotentialMovesFrom([x, y]);
    }
  }

  // Pawns jump 2 or 3 squares, and promote to queen or wildebeest
  getPotentialPawnMoves([x, y]) {
    const color = this.turn;
    let moves = [];
    const [sizeX, sizeY] = [V.size.x, V.size.y];
    const shiftX = color == "w" ? -1 : 1;
    const startRanks = color == "w" ? [sizeX - 2, sizeX - 3] : [1, 2];
    const lastRanks = color == "w" ? [0, 1] : [sizeX - 1, sizeX  -2];
    let finalPieces = [V.PAWN];
    if (x + shiftX == lastRanks[1])
      Array.prototype.push.apply(finalPieces, [V.WILDEBEEST, V.QUEEN]);
    else if (x + shiftX == lastRanks[0])
      finalPieces = [V.WILDEBEEST, V.QUEEN];

    if (this.board[x + shiftX][y] == V.EMPTY) {
      // One square forward
      for (let piece of finalPieces)
        moves.push(
          this.getBasicMove([x, y], [x + shiftX, y], { c: color, p: piece })
        );
      if (startRanks.includes(x)) {
        if (this.board[x + 2 * shiftX][y] == V.EMPTY) {
          // Two squares jump
          moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
          if (x == startRanks[0] && this.board[x + 3 * shiftX][y] == V.EMPTY) {
            // Three squares jump
            moves.push(this.getBasicMove([x, y], [x + 3 * shiftX, y]));
          }
        }
      }
    }
    // Captures
    for (let shiftY of [-1, 1]) {
      if (
        y + shiftY >= 0 &&
        y + shiftY < sizeY &&
        this.board[x + shiftX][y + shiftY] != V.EMPTY &&
        this.canTake([x, y], [x + shiftX, y + shiftY])
      ) {
        for (let piece of finalPieces) {
          moves.push(
            this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
              c: color,
              p: piece
            })
          );
        }
      }
    }

    // En passant
    const Lep = this.epSquares.length;
    const epSquare = this.epSquares[Lep - 1];
    if (!!epSquare) {
      for (let epsq of epSquare) {
        // TODO: some redundant checks
        if (epsq.x == x + shiftX && Math.abs(epsq.y - y) == 1) {
          let enpassantMove = this.getBasicMove([x, y], [epsq.x, epsq.y]);
          // WARNING: the captured pawn may be diagonally behind us,
          // if it's a 3-squares jump and we take on 1st passing square
          const px = this.board[x][epsq.y] != V.EMPTY ? x : x - shiftX;
          enpassantMove.vanish.push({
            x: px,
            y: epsq.y,
            p: "p",
            c: this.getColor(px, epsq.y)
          });
          moves.push(enpassantMove);
        }
      }
    }

    return moves;
  }

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

  getPotentialWildebeestMoves(sq) {
    return this.getSlideNJumpMoves(
      sq, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), 1);
  }

  getPPpath(m) {
    if (
      m.appear.length == 2 && m.vanish.length == 2 &&
      Math.abs(m.end.y - m.start.y) == 1 &&
      this.board[m.end.x][m.end.y] == V.EMPTY
    ) {
      // Castle, king moved by one square only, not directly onto rook
      return "Wildebeest/castle";
    }
    return super.getPPpath(m);
  }

  // Special Wildebeest castling rules:
  getCastleMoves([x, y]) {
    const c = this.getColor(x, y);
    const oppCol = V.GetOppCol(c);
    let moves = [];
    let i = 0;
    const castlingKing = this.board[x][y].charAt(1);
    castlingCheck: for (
      let castleSide = 0;
      castleSide < 2;
      castleSide++ //"large", then "small"
    ) {
      if (this.castleFlags[c][castleSide] >= V.size.y) continue;
      // Rook and king are on initial position
      const rookPos = this.castleFlags[c][castleSide];
      const range = (castleSide == 0 ? [rookPos, y] : [y, rookPos]);

      // King and rook must be connected:
      for (let i = range[0] + 1; i <= range[1] - 1; i++) {
        if (this.board[x][i] != V.EMPTY) continue castlingCheck;
      }
      const step = 2 * castleSide - 1;
      // No attacks on the path of the king ?
      for (let i = range[0]; i <= range[1]; i++) {
        if (i != rookPos && this.isAttacked([x, i], oppCol))
          continue castlingCheck;
        if (
          i != y &&
          // Do not end in the corner, except if starting square is too near
          (i > 0 || y == 1) &&
          (i < V.size.y - 1 || y == V.size.y - 2)
        ) {
          // Found a possible castle move:
          moves.push(
            new Move({
              appear: [
                new PiPo({
                  x: x,
                  y: i,
                  p: V.KING,
                  c: c
                }),
                new PiPo({
                  x: x,
                  y: i - step,
                  p: V.ROOK,
                  c: c
                })
              ],
              vanish: [
                new PiPo({ x: x, y: y, p: V.KING, c: c }),
                new PiPo({ x: x, y: rookPos, p: V.ROOK, c: c })
              ]
            })
          );
        }
      }
    }

    return moves;
  }

  isAttacked(sq, color) {
    return (
      super.isAttacked(sq, color) ||
      this.isAttackedByCamel(sq, color) ||
      this.isAttackedByWildebeest(sq, color)
    );
  }

  isAttackedByCamel(sq, color) {
    return this.isAttackedBySlideNJump(
      sq, color, V.CAMEL, V.steps[V.CAMEL], 1);
  }

  isAttackedByWildebeest(sq, color) {
    return this.isAttackedBySlideNJump(
      sq, color, V.WILDEBEEST, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), 1);
  }

  getCurrentScore() {
    if (this.atLeastOneMove()) return "*";
    // No valid move: game is lost (stalemate is a win)
    return this.turn == "w" ? "0-1" : "1-0";
  }

  static get VALUES() {
    return Object.assign(
      { c: 3, w: 7 }, //experimental
      ChessRules.VALUES
    );
  }

  static get SEARCH_DEPTH() {
    return 2;
  }

  static GenRandInitFen(options) {
    if (options.randomness == 0) {
      return (
        "rnccwkqbbnr/ppppppppppp/92/92/92/92/92/92/PPPPPPPPPPP/RNBBQKWCCNR " +
        "w 0 akak -"
      );
    }

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

      let positions = ArrayFun.range(11);

      // Get random squares for bishops + camels (different colors)
      let randIndexes = sample(ArrayFun.range(6), 2).map(i => {
        return 2 * i;
      });
      let bishop1Pos = positions[randIndexes[0]];
      let camel1Pos = positions[randIndexes[1]];
      // The second bishop (camel) must be on a square of different color
      let randIndexes_tmp = sample(ArrayFun.range(5), 2).map(i => {
        return 2 * i + 1;
      });
      let bishop2Pos = positions[randIndexes_tmp[0]];
      let camel2Pos = positions[randIndexes_tmp[1]];
      for (let idx of randIndexes.concat(randIndexes_tmp).sort((a, b) => {
        return b - a;
      })) {
        // Largest indices first
        positions.splice(idx, 1);
      }

      let randIndex = randInt(7);
      let knight1Pos = positions[randIndex];
      positions.splice(randIndex, 1);
      randIndex = randInt(6);
      let knight2Pos = positions[randIndex];
      positions.splice(randIndex, 1);

      randIndex = randInt(5);
      let queenPos = positions[randIndex];
      positions.splice(randIndex, 1);

      // Random square for wildebeest
      randIndex = randInt(4);
      let wildebeestPos = positions[randIndex];
      positions.splice(randIndex, 1);

      let rook1Pos = positions[0];
      let kingPos = positions[1];
      let rook2Pos = positions[2];

      pieces[c][rook1Pos] = "r";
      pieces[c][knight1Pos] = "n";
      pieces[c][bishop1Pos] = "b";
      pieces[c][queenPos] = "q";
      pieces[c][camel1Pos] = "c";
      pieces[c][camel2Pos] = "c";
      pieces[c][wildebeestPos] = "w";
      pieces[c][kingPos] = "k";
      pieces[c][bishop2Pos] = "b";
      pieces[c][knight2Pos] = "n";
      pieces[c][rook2Pos] = "r";
      flags += V.CoordToColumn(rook1Pos) + V.CoordToColumn(rook2Pos);
    }
    return (
      pieces["b"].join("") +
      "/ppppppppppp/92/92/92/92/92/92/PPPPPPPPPPP/" +
      pieces["w"].join("").toUpperCase() +
      " w 0 " + flags + " -"
    );
  }

};
Commit	Line	Data
	1	import { ChessRules, Move, PiPo } from "@/base_rules";
	2	import { ArrayFun } from "@/utils/array";
	3	import { sample, randInt } from "@/utils/alea";
	4
	5	export class WildebeestRules extends ChessRules {
	6
	7	static get size() {
	8	return { x: 10, y: 11 };
	9	}
	10
	11	static get CAMEL() {
	12	return "c";
	13	}
	14	static get WILDEBEEST() {
	15	return "w";
	16	}
	17
	18	static get PIECES() {
	19	return ChessRules.PIECES.concat([V.CAMEL, V.WILDEBEEST]);
	20	}
	21
	22	static get steps() {
	23	return Object.assign(
	24	{},
	25	ChessRules.steps,
	26	// Add camel moves:
	27	{
	28	c: [
	29	[-3, -1],
	30	[-3, 1],
	31	[-1, -3],
	32	[-1, 3],
	33	[1, -3],
	34	[1, 3],
	35	[3, -1],
	36	[3, 1]
	37	]
	38	}
	39	);
	40	}
	41
	42	static IsGoodEnpassant(enpassant) {
	43	if (enpassant != "-") return !!enpassant.match(/^([a-j][0-9]{1,2},?)+$/);
	44	return true;
	45	}
	46
	47	getPpath(b) {
	48	return ([V.CAMEL, V.WILDEBEEST].includes(b[1]) ? "Wildebeest/" : "") + b;
	49	}
	50
	51	// There may be 2 enPassant squares (if pawn jump 3 squares)
	52	getEnpassantFen() {
	53	const L = this.epSquares.length;
	54	if (!this.epSquares[L - 1]) return "-"; //no en-passant
	55	let res = "";
	56	this.epSquares[L - 1].forEach(sq => {
	57	res += V.CoordsToSquare(sq) + ",";
	58	});
	59	return res.slice(0, -1); //remove last comma
	60	}
	61
	62	// En-passant after 2-sq or 3-sq jumps
	63	getEpSquare(moveOrSquare) {
	64	if (!moveOrSquare) return undefined;
	65	if (typeof moveOrSquare === "string") {
	66	const square = moveOrSquare;
	67	if (square == "-") return undefined;
	68	let res = [];
	69	square.split(",").forEach(sq => {
	70	res.push(V.SquareToCoords(sq));
	71	});
	72	return res;
	73	}
	74	// Argument is a move:
	75	const move = moveOrSquare;
	76	const [sx, sy, ex] = [move.start.x, move.start.y, move.end.x];
	77	if (this.getPiece(sx, sy) == V.PAWN && Math.abs(sx - ex) >= 2) {
	78	const step = (ex - sx) / Math.abs(ex - sx);
	79	let res = [
	80	{
	81	x: sx + step,
	82	y: sy
	83	}
	84	];
	85	if (sx + 2 * step != ex) {
	86	// 3-squares move
	87	res.push({
	88	x: sx + 2 * step,
	89	y: sy
	90	});
	91	}
	92	return res;
	93	}
	94	return undefined; //default
	95	}
	96
	97	getPotentialMovesFrom([x, y]) {
	98	switch (this.getPiece(x, y)) {
	99	case V.CAMEL:
	100	return this.getPotentialCamelMoves([x, y]);
	101	case V.WILDEBEEST:
	102	return this.getPotentialWildebeestMoves([x, y]);
	103	default:
	104	return super.getPotentialMovesFrom([x, y]);
	105	}
	106	}
	107
	108	// Pawns jump 2 or 3 squares, and promote to queen or wildebeest
	109	getPotentialPawnMoves([x, y]) {
	110	const color = this.turn;
	111	let moves = [];
	112	const [sizeX, sizeY] = [V.size.x, V.size.y];
	113	const shiftX = color == "w" ? -1 : 1;
	114	const startRanks = color == "w" ? [sizeX - 2, sizeX - 3] : [1, 2];
	115	const lastRanks = color == "w" ? [0, 1] : [sizeX - 1, sizeX -2];
	116	let finalPieces = [V.PAWN];
	117	if (x + shiftX == lastRanks[1])
	118	Array.prototype.push.apply(finalPieces, [V.WILDEBEEST, V.QUEEN]);
	119	else if (x + shiftX == lastRanks[0])
	120	finalPieces = [V.WILDEBEEST, V.QUEEN];
	121
	122	if (this.board[x + shiftX][y] == V.EMPTY) {
	123	// One square forward
	124	for (let piece of finalPieces)
	125	moves.push(
	126	this.getBasicMove([x, y], [x + shiftX, y], { c: color, p: piece })
	127	);
	128	if (startRanks.includes(x)) {
	129	if (this.board[x + 2 * shiftX][y] == V.EMPTY) {
	130	// Two squares jump
	131	moves.push(this.getBasicMove([x, y], [x + 2 * shiftX, y]));
	132	if (x == startRanks[0] && this.board[x + 3 * shiftX][y] == V.EMPTY) {
	133	// Three squares jump
	134	moves.push(this.getBasicMove([x, y], [x + 3 * shiftX, y]));
	135	}
	136	}
	137	}
	138	}
	139	// Captures
	140	for (let shiftY of [-1, 1]) {
	141	if (
	142	y + shiftY >= 0 &&
	143	y + shiftY < sizeY &&
	144	this.board[x + shiftX][y + shiftY] != V.EMPTY &&
	145	this.canTake([x, y], [x + shiftX, y + shiftY])
	146	) {
	147	for (let piece of finalPieces) {
	148	moves.push(
	149	this.getBasicMove([x, y], [x + shiftX, y + shiftY], {
	150	c: color,
	151	p: piece
	152	})
	153	);
	154	}
	155	}
	156	}
	157
	158	// En passant
	159	const Lep = this.epSquares.length;
	160	const epSquare = this.epSquares[Lep - 1];
	161	if (!!epSquare) {
	162	for (let epsq of epSquare) {
	163	// TODO: some redundant checks
	164	if (epsq.x == x + shiftX && Math.abs(epsq.y - y) == 1) {
	165	let enpassantMove = this.getBasicMove([x, y], [epsq.x, epsq.y]);
	166	// WARNING: the captured pawn may be diagonally behind us,
	167	// if it's a 3-squares jump and we take on 1st passing square
	168	const px = this.board[x][epsq.y] != V.EMPTY ? x : x - shiftX;
	169	enpassantMove.vanish.push({
	170	x: px,
	171	y: epsq.y,
	172	p: "p",
	173	c: this.getColor(px, epsq.y)
	174	});
	175	moves.push(enpassantMove);
	176	}
	177	}
	178	}
	179
	180	return moves;
	181	}
	182
	183	getPotentialCamelMoves(sq) {
	184	return this.getSlideNJumpMoves(sq, V.steps[V.CAMEL], 1);
	185	}
	186
	187	getPotentialWildebeestMoves(sq) {
	188	return this.getSlideNJumpMoves(
	189	sq, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), 1);
	190	}
	191
	192	getPPpath(m) {
	193	if (
	194	m.appear.length == 2 && m.vanish.length == 2 &&
	195	Math.abs(m.end.y - m.start.y) == 1 &&
	196	this.board[m.end.x][m.end.y] == V.EMPTY
	197	) {
	198	// Castle, king moved by one square only, not directly onto rook
	199	return "Wildebeest/castle";
	200	}
	201	return super.getPPpath(m);
	202	}
	203
	204	// Special Wildebeest castling rules:
	205	getCastleMoves([x, y]) {
	206	const c = this.getColor(x, y);
	207	const oppCol = V.GetOppCol(c);
	208	let moves = [];
	209	let i = 0;
	210	const castlingKing = this.board[x][y].charAt(1);
	211	castlingCheck: for (
	212	let castleSide = 0;
	213	castleSide < 2;
	214	castleSide++ //"large", then "small"
	215	) {
	216	if (this.castleFlags[c][castleSide] >= V.size.y) continue;
	217	// Rook and king are on initial position
	218	const rookPos = this.castleFlags[c][castleSide];
	219	const range = (castleSide == 0 ? [rookPos, y] : [y, rookPos]);
	220
	221	// King and rook must be connected:
	222	for (let i = range[0] + 1; i <= range[1] - 1; i++) {
	223	if (this.board[x][i] != V.EMPTY) continue castlingCheck;
	224	}
	225	const step = 2 * castleSide - 1;
	226	// No attacks on the path of the king ?
	227	for (let i = range[0]; i <= range[1]; i++) {
	228	if (i != rookPos && this.isAttacked([x, i], oppCol))
	229	continue castlingCheck;
	230	if (
	231	i != y &&
	232	// Do not end in the corner, except if starting square is too near
	233	(i > 0 \|\| y == 1) &&
	234	(i < V.size.y - 1 \|\| y == V.size.y - 2)
	235	) {
	236	// Found a possible castle move:
	237	moves.push(
	238	new Move({
	239	appear: [
	240	new PiPo({
	241	x: x,
	242	y: i,
	243	p: V.KING,
	244	c: c
	245	}),
	246	new PiPo({
	247	x: x,
	248	y: i - step,
	249	p: V.ROOK,
	250	c: c
	251	})
	252	],
	253	vanish: [
	254	new PiPo({ x: x, y: y, p: V.KING, c: c }),
	255	new PiPo({ x: x, y: rookPos, p: V.ROOK, c: c })
	256	]
	257	})
	258	);
	259	}
	260	}
	261	}
	262
	263	return moves;
	264	}
	265
	266	isAttacked(sq, color) {
	267	return (
	268	super.isAttacked(sq, color) \|\|
	269	this.isAttackedByCamel(sq, color) \|\|
	270	this.isAttackedByWildebeest(sq, color)
	271	);
	272	}
	273
	274	isAttackedByCamel(sq, color) {
	275	return this.isAttackedBySlideNJump(
	276	sq, color, V.CAMEL, V.steps[V.CAMEL], 1);
	277	}
	278
	279	isAttackedByWildebeest(sq, color) {
	280	return this.isAttackedBySlideNJump(
	281	sq, color, V.WILDEBEEST, V.steps[V.KNIGHT].concat(V.steps[V.CAMEL]), 1);
	282	}
	283
	284	getCurrentScore() {
	285	if (this.atLeastOneMove()) return "*";
	286	// No valid move: game is lost (stalemate is a win)
	287	return this.turn == "w" ? "0-1" : "1-0";
	288	}
	289
	290	static get VALUES() {
	291	return Object.assign(
	292	{ c: 3, w: 7 }, //experimental
	293	ChessRules.VALUES
	294	);
	295	}
	296
	297	static get SEARCH_DEPTH() {
	298	return 2;
	299	}
	300
	301	static GenRandInitFen(options) {
	302	if (options.randomness == 0) {
	303	return (
	304	"rnccwkqbbnr/ppppppppppp/92/92/92/92/92/92/PPPPPPPPPPP/RNBBQKWCCNR " +
	305	"w 0 akak -"
	306	);
	307	}
	308
	309	let pieces = { w: new Array(11), b: new Array(11) };
	310	let flags = "";
	311	for (let c of ["w", "b"]) {
	312	if (c == 'b' && options.randomness == 1) {
	313	pieces['b'] = pieces['w'];
	314	flags += flags;
	315	break;
	316	}
	317
	318	let positions = ArrayFun.range(11);
	319
	320	// Get random squares for bishops + camels (different colors)
	321	let randIndexes = sample(ArrayFun.range(6), 2).map(i => {
	322	return 2 * i;
	323	});
	324	let bishop1Pos = positions[randIndexes[0]];
	325	let camel1Pos = positions[randIndexes[1]];
	326	// The second bishop (camel) must be on a square of different color
	327	let randIndexes_tmp = sample(ArrayFun.range(5), 2).map(i => {
	328	return 2 * i + 1;
	329	});
	330	let bishop2Pos = positions[randIndexes_tmp[0]];
	331	let camel2Pos = positions[randIndexes_tmp[1]];
	332	for (let idx of randIndexes.concat(randIndexes_tmp).sort((a, b) => {
	333	return b - a;
	334	})) {
	335	// Largest indices first
	336	positions.splice(idx, 1);
	337	}
	338
	339	let randIndex = randInt(7);
	340	let knight1Pos = positions[randIndex];
	341	positions.splice(randIndex, 1);
	342	randIndex = randInt(6);
	343	let knight2Pos = positions[randIndex];
	344	positions.splice(randIndex, 1);
	345
	346	randIndex = randInt(5);
	347	let queenPos = positions[randIndex];
	348	positions.splice(randIndex, 1);
	349
	350	// Random square for wildebeest
	351	randIndex = randInt(4);
	352	let wildebeestPos = positions[randIndex];
	353	positions.splice(randIndex, 1);
	354
	355	let rook1Pos = positions[0];
	356	let kingPos = positions[1];
	357	let rook2Pos = positions[2];
	358
	359	pieces[c][rook1Pos] = "r";
	360	pieces[c][knight1Pos] = "n";
	361	pieces[c][bishop1Pos] = "b";
	362	pieces[c][queenPos] = "q";
	363	pieces[c][camel1Pos] = "c";
	364	pieces[c][camel2Pos] = "c";
	365	pieces[c][wildebeestPos] = "w";
	366	pieces[c][kingPos] = "k";
	367	pieces[c][bishop2Pos] = "b";
	368	pieces[c][knight2Pos] = "n";
	369	pieces[c][rook2Pos] = "r";
	370	flags += V.CoordToColumn(rook1Pos) + V.CoordToColumn(rook2Pos);
	371	}
	372	return (
	373	pieces["b"].join("") +
	374	"/ppppppppppp/92/92/92/92/92/92/PPPPPPPPPPP/" +
	375	pieces["w"].join("").toUpperCase() +
	376	" w 0 " + flags + " -"
	377	);
	378	}
	379
	380	};