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

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

export class DarkRules extends ChessRules {

  // Analyse in Dark mode makes no sense
  static get CanAnalyze() {
    return false;
  }

  // Moves are revealed only when game ends
  static get ShowMoves() {
    return "none";
  }

  static get SomeHiddenMoves() {
    return true;
  }

  setOtherVariables(fen) {
    super.setOtherVariables(fen);
    const [sizeX, sizeY] = [V.size.x, V.size.y];
    this.enlightened = {
      w: ArrayFun.init(sizeX, sizeY),
      b: ArrayFun.init(sizeX, sizeY)
    };
    // Setup enlightened: squares reachable by each side
    // (TODO: one side would be enough ?)
    this.updateEnlightened();
  }

  updateEnlightened() {
    for (let i = 0; i < V.size.x; i++) {
      for (let j = 0; j < V.size.y; j++) {
        this.enlightened["w"][i][j] = false;
        this.enlightened["b"][i][j] = false;
      }
    }
    const pawnShift = { w: -1, b: 1 };
    // Initialize with pieces positions (which are seen)
    for (let i = 0; i < V.size.x; i++) {
      for (let j = 0; j < V.size.y; j++) {
        if (this.board[i][j] != V.EMPTY) {
          const c = this.getColor(i, j);
          this.enlightened[c][i][j] = true;
          // Add potential squares visible by "impossible pawn capture"
          if (this.getPiece(i, j) == V.PAWN) {
            for (let shiftY of [-1, 1]) {
              if (
                V.OnBoard(i + pawnShift[c], j + shiftY) &&
                this.board[i + pawnShift[c]][j + shiftY] == V.EMPTY
              ) {
                this.enlightened[c][i + pawnShift[c]][j + shiftY] = true;
              }
            }
          }
        }
      }
    }
    const currentTurn = this.turn;
    this.turn = "w";
    const movesWhite = this.getAllValidMoves();
    this.turn = "b";
    const movesBlack = this.getAllValidMoves();
    this.turn = currentTurn;
    for (let move of movesWhite)
      this.enlightened["w"][move.end.x][move.end.y] = true;
    for (let move of movesBlack)
      this.enlightened["b"][move.end.x][move.end.y] = true;
    // Include en-passant capturing square if any:
    let moves = currentTurn == "w" ? movesWhite : movesBlack;
    for (let m of moves) {
      if (
        m.appear[0].p == V.PAWN &&
        m.vanish.length == 2 &&
        m.vanish[1].x != m.end.x
      ) {
        const psq = m.vanish[1];
        this.enlightened[currentTurn][psq.x][psq.y] = true;
        break;
      }
    }
  }

  // To always allow castling:
  isAttacked() {
    return false;
  }

  filterValid(moves) {
    // Used in the interface
    return moves;
  }

  // Has to be redefined to avoid an infinite loop
  getAllValidMoves() {
    const color = this.turn;
    let potentialMoves = [];
    for (let i = 0; i < V.size.x; i++) {
      for (let j = 0; j < V.size.y; j++) {
        if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color)
          Array.prototype.push.apply(
            potentialMoves,
            this.getPotentialMovesFrom([i, j])
          );
      }
    }
    return potentialMoves; //because there are no checks
  }

  getCheckSquares() {
    return [];
  }

  postPlay(move) {
    super.postPlay(move);
    if (move.vanish.length == 2 && move.vanish[1].p == V.KING)
      // We took opponent king (because if castle vanish[1] is a rook)
      this.kingPos[this.turn] = [-1, -1];

    // Update lights for both colors:
    this.updateEnlightened();
  }

  postUndo(move) {
    super.postUndo(move);
    if (move.vanish.length == 2 && move.vanish[1].p == V.KING)
      // Last move took opponent's king:
      this.kingPos[move.vanish[1].c] = [move.vanish[1].x, move.vanish[1].y];

    // Update lights for both colors:
    this.updateEnlightened();
  }

  getCurrentScore() {
    const color = this.turn;
    const kp = this.kingPos[color];
    if (kp[0] < 0)
      // King disappeared
      return color == "w" ? "0-1" : "1-0";
    // Assume that stalemate is impossible (I think so. Would need proof...)
    return "*";
  }

  static get THRESHOLD_MATE() {
    return 500; //checkmates evals may be slightly below 1000
  }

  // In this special situation, we just look 1 half move ahead
  getComputerMove() {
    const maxeval = V.INFINITY;
    const color = this.turn;
    const oppCol = V.GetOppCol(color);
    const pawnShift = color == "w" ? -1 : 1;

    // Do not cheat: the current enlightment is all we can see
    const myLight = JSON.parse(JSON.stringify(this.enlightened[color]));

    // Can a slider on (i,j) apparently take my king?
    // NOTE: inaccurate because assume yes if some squares are shadowed
    const sliderTake = ([i, j], piece) => {
      const kp = this.kingPos[color];
      let step = undefined;
      if (piece == V.BISHOP) {
        if (Math.abs(kp[0] - i) == Math.abs(kp[1] - j)) {
          step = [
            (i - kp[0]) / Math.abs(i - kp[0]),
            (j - kp[1]) / Math.abs(j - kp[1])
          ];
        }
      } else if (piece == V.ROOK) {
        if (kp[0] == i) step = [0, (j - kp[1]) / Math.abs(j - kp[1])];
        else if (kp[1] == j) step = [(i - kp[0]) / Math.abs(i - kp[0]), 0];
      }
      if (!step) return false;
      // Check for obstacles
      let obstacle = false;
      for (
        let x = kp[0] + step[0], y = kp[1] + step[1];
        x != i && y != j;
        x += step[0], y += step[1]
      ) {
        if (myLight[x][y] && this.board[x][y] != V.EMPTY) {
          obstacle = true;
          break;
        }
      }
      if (!obstacle) return true;
      return false;
    };

    // Do I see something which can take my king ?
    const kingThreats = () => {
      const kp = this.kingPos[color];
      for (let i = 0; i < V.size.x; i++) {
        for (let j = 0; j < V.size.y; j++) {
          if (
            myLight[i][j] &&
            this.board[i][j] != V.EMPTY &&
            this.getColor(i, j) != color
          ) {
            switch (this.getPiece(i, j)) {
              case V.PAWN:
                if (kp[0] + pawnShift == i && Math.abs(kp[1] - j) == 1)
                  return true;
                break;
              case V.KNIGHT:
                if (
                  (Math.abs(kp[0] - i) == 2 && Math.abs(kp[1] - j) == 1) ||
                  (Math.abs(kp[0] - i) == 1 && Math.abs(kp[1] - j) == 2)
                ) {
                  return true;
                }
                break;
              case V.KING:
                if (Math.abs(kp[0] - i) == 1 && Math.abs(kp[1] - j) == 1)
                  return true;
                break;
              case V.BISHOP:
                if (sliderTake([i, j], V.BISHOP)) return true;
                break;
              case V.ROOK:
                if (sliderTake([i, j], V.ROOK)) return true;
                break;
              case V.QUEEN:
                if (sliderTake([i, j], V.BISHOP) || sliderTake([i, j], V.ROOK))
                  return true;
                break;
            }
          }
        }
      }
      return false;
    };

    let moves = this.getAllValidMoves();
    for (let move of moves) {
      this.play(move);
      if (this.kingPos[oppCol][0] >= 0 && kingThreats()) {
        // We didn't take opponent king, and our king will be captured: bad
        move.eval = -maxeval;
      }
      this.undo(move);

      if (move.eval) continue;

      move.eval = 0; //a priori...

      // Can I take something ? If yes, do it if it seems good...
      if (move.vanish.length == 2 && move.vanish[1].c != color) {
        // OK this isn't a castling move
        const myPieceVal = V.VALUES[move.appear[0].p];
        const hisPieceVal = V.VALUES[move.vanish[1].p];
        // Favor captures
        if (myPieceVal <= hisPieceVal)
          move.eval = hisPieceVal - myPieceVal + 1;
        else {
          // Taking a pawn with minor piece,
          // or minor piece or pawn with a rook,
          // or anything but a queen with a queen,
          // or anything with a king.
          move.eval = hisPieceVal - myPieceVal;
                      //Math.random() < 0.5 ? 1 : -1;
        }
      }
    }

    // TODO: also need to implement the case when an opponent piece (in light)
    // is threatening something - maybe not the king, but e.g. pawn takes rook.

    moves.sort((a, b) => b.eval - a.eval);
    let candidates = [0];
    for (let j = 1; j < moves.length && moves[j].eval == moves[0].eval; j++)
      candidates.push(j);
    return moves[candidates[randInt(candidates.length)]];
  }

};
Commit	Line	Data
	1	import { ChessRules } from "@/base_rules";
	2	import { ArrayFun } from "@/utils/array";
	3	import { randInt } from "@/utils/alea";
	4
	5	export class DarkRules extends ChessRules {
	6
	7	// Analyse in Dark mode makes no sense
	8	static get CanAnalyze() {
	9	return false;
	10	}
	11
	12	// Moves are revealed only when game ends
	13	static get ShowMoves() {
	14	return "none";
	15	}
	16
	17	static get SomeHiddenMoves() {
	18	return true;
	19	}
	20
	21	setOtherVariables(fen) {
	22	super.setOtherVariables(fen);
	23	const [sizeX, sizeY] = [V.size.x, V.size.y];
	24	this.enlightened = {
	25	w: ArrayFun.init(sizeX, sizeY),
	26	b: ArrayFun.init(sizeX, sizeY)
	27	};
	28	// Setup enlightened: squares reachable by each side
	29	// (TODO: one side would be enough ?)
	30	this.updateEnlightened();
	31	}
	32
	33	updateEnlightened() {
	34	for (let i = 0; i < V.size.x; i++) {
	35	for (let j = 0; j < V.size.y; j++) {
	36	this.enlightened["w"][i][j] = false;
	37	this.enlightened["b"][i][j] = false;
	38	}
	39	}
	40	const pawnShift = { w: -1, b: 1 };
	41	// Initialize with pieces positions (which are seen)
	42	for (let i = 0; i < V.size.x; i++) {
	43	for (let j = 0; j < V.size.y; j++) {
	44	if (this.board[i][j] != V.EMPTY) {
	45	const c = this.getColor(i, j);
	46	this.enlightened[c][i][j] = true;
	47	// Add potential squares visible by "impossible pawn capture"
	48	if (this.getPiece(i, j) == V.PAWN) {
	49	for (let shiftY of [-1, 1]) {
	50	if (
	51	V.OnBoard(i + pawnShift[c], j + shiftY) &&
	52	this.board[i + pawnShift[c]][j + shiftY] == V.EMPTY
	53	) {
	54	this.enlightened[c][i + pawnShift[c]][j + shiftY] = true;
	55	}
	56	}
	57	}
	58	}
	59	}
	60	}
	61	const currentTurn = this.turn;
	62	this.turn = "w";
	63	const movesWhite = this.getAllValidMoves();
	64	this.turn = "b";
	65	const movesBlack = this.getAllValidMoves();
	66	this.turn = currentTurn;
	67	for (let move of movesWhite)
	68	this.enlightened["w"][move.end.x][move.end.y] = true;
	69	for (let move of movesBlack)
	70	this.enlightened["b"][move.end.x][move.end.y] = true;
	71	// Include en-passant capturing square if any:
	72	let moves = currentTurn == "w" ? movesWhite : movesBlack;
	73	for (let m of moves) {
	74	if (
	75	m.appear[0].p == V.PAWN &&
	76	m.vanish.length == 2 &&
	77	m.vanish[1].x != m.end.x
	78	) {
	79	const psq = m.vanish[1];
	80	this.enlightened[currentTurn][psq.x][psq.y] = true;
	81	break;
	82	}
	83	}
	84	}
	85
	86	// To always allow castling:
	87	isAttacked() {
	88	return false;
	89	}
	90
	91	filterValid(moves) {
	92	// Used in the interface
	93	return moves;
	94	}
	95
	96	// Has to be redefined to avoid an infinite loop
	97	getAllValidMoves() {
	98	const color = this.turn;
	99	let potentialMoves = [];
	100	for (let i = 0; i < V.size.x; i++) {
	101	for (let j = 0; j < V.size.y; j++) {
	102	if (this.board[i][j] != V.EMPTY && this.getColor(i, j) == color)
	103	Array.prototype.push.apply(
	104	potentialMoves,
	105	this.getPotentialMovesFrom([i, j])
	106	);
	107	}
	108	}
	109	return potentialMoves; //because there are no checks
	110	}
	111
	112	getCheckSquares() {
	113	return [];
	114	}
	115
	116	postPlay(move) {
	117	super.postPlay(move);
	118	if (move.vanish.length == 2 && move.vanish[1].p == V.KING)
	119	// We took opponent king (because if castle vanish[1] is a rook)
	120	this.kingPos[this.turn] = [-1, -1];
	121
	122	// Update lights for both colors:
	123	this.updateEnlightened();
	124	}
	125
	126	postUndo(move) {
	127	super.postUndo(move);
	128	if (move.vanish.length == 2 && move.vanish[1].p == V.KING)
	129	// Last move took opponent's king:
	130	this.kingPos[move.vanish[1].c] = [move.vanish[1].x, move.vanish[1].y];
	131
	132	// Update lights for both colors:
	133	this.updateEnlightened();
	134	}
	135
	136	getCurrentScore() {
	137	const color = this.turn;
	138	const kp = this.kingPos[color];
	139	if (kp[0] < 0)
	140	// King disappeared
	141	return color == "w" ? "0-1" : "1-0";
	142	// Assume that stalemate is impossible (I think so. Would need proof...)
	143	return "*";
	144	}
	145
	146	static get THRESHOLD_MATE() {
	147	return 500; //checkmates evals may be slightly below 1000
	148	}
	149
	150	// In this special situation, we just look 1 half move ahead
	151	getComputerMove() {
	152	const maxeval = V.INFINITY;
	153	const color = this.turn;
	154	const oppCol = V.GetOppCol(color);
	155	const pawnShift = color == "w" ? -1 : 1;
	156
	157	// Do not cheat: the current enlightment is all we can see
	158	const myLight = JSON.parse(JSON.stringify(this.enlightened[color]));
	159
	160	// Can a slider on (i,j) apparently take my king?
	161	// NOTE: inaccurate because assume yes if some squares are shadowed
	162	const sliderTake = ([i, j], piece) => {
	163	const kp = this.kingPos[color];
	164	let step = undefined;
	165	if (piece == V.BISHOP) {
	166	if (Math.abs(kp[0] - i) == Math.abs(kp[1] - j)) {
	167	step = [
	168	(i - kp[0]) / Math.abs(i - kp[0]),
	169	(j - kp[1]) / Math.abs(j - kp[1])
	170	];
	171	}
	172	} else if (piece == V.ROOK) {
	173	if (kp[0] == i) step = [0, (j - kp[1]) / Math.abs(j - kp[1])];
	174	else if (kp[1] == j) step = [(i - kp[0]) / Math.abs(i - kp[0]), 0];
	175	}
	176	if (!step) return false;
	177	// Check for obstacles
	178	let obstacle = false;
	179	for (
	180	let x = kp[0] + step[0], y = kp[1] + step[1];
	181	x != i && y != j;
	182	x += step[0], y += step[1]
	183	) {
	184	if (myLight[x][y] && this.board[x][y] != V.EMPTY) {
	185	obstacle = true;
	186	break;
	187	}
	188	}
	189	if (!obstacle) return true;
	190	return false;
	191	};
	192
	193	// Do I see something which can take my king ?
	194	const kingThreats = () => {
	195	const kp = this.kingPos[color];
	196	for (let i = 0; i < V.size.x; i++) {
	197	for (let j = 0; j < V.size.y; j++) {
	198	if (
	199	myLight[i][j] &&
	200	this.board[i][j] != V.EMPTY &&
	201	this.getColor(i, j) != color
	202	) {
	203	switch (this.getPiece(i, j)) {
	204	case V.PAWN:
	205	if (kp[0] + pawnShift == i && Math.abs(kp[1] - j) == 1)
	206	return true;
	207	break;
	208	case V.KNIGHT:
	209	if (
	210	(Math.abs(kp[0] - i) == 2 && Math.abs(kp[1] - j) == 1) \|\|
	211	(Math.abs(kp[0] - i) == 1 && Math.abs(kp[1] - j) == 2)
	212	) {
	213	return true;
	214	}
	215	break;
	216	case V.KING:
	217	if (Math.abs(kp[0] - i) == 1 && Math.abs(kp[1] - j) == 1)
	218	return true;
	219	break;
	220	case V.BISHOP:
	221	if (sliderTake([i, j], V.BISHOP)) return true;
	222	break;
	223	case V.ROOK:
	224	if (sliderTake([i, j], V.ROOK)) return true;
	225	break;
	226	case V.QUEEN:
	227	if (sliderTake([i, j], V.BISHOP) \|\| sliderTake([i, j], V.ROOK))
	228	return true;
	229	break;
	230	}
	231	}
	232	}
	233	}
	234	return false;
	235	};
	236
	237	let moves = this.getAllValidMoves();
	238	for (let move of moves) {
	239	this.play(move);
	240	if (this.kingPos[oppCol][0] >= 0 && kingThreats()) {
	241	// We didn't take opponent king, and our king will be captured: bad
	242	move.eval = -maxeval;
	243	}
	244	this.undo(move);
	245
	246	if (move.eval) continue;
	247
	248	move.eval = 0; //a priori...
	249
	250	// Can I take something ? If yes, do it if it seems good...
	251	if (move.vanish.length == 2 && move.vanish[1].c != color) {
	252	// OK this isn't a castling move
	253	const myPieceVal = V.VALUES[move.appear[0].p];
	254	const hisPieceVal = V.VALUES[move.vanish[1].p];
	255	// Favor captures
	256	if (myPieceVal <= hisPieceVal)
	257	move.eval = hisPieceVal - myPieceVal + 1;
	258	else {
	259	// Taking a pawn with minor piece,
	260	// or minor piece or pawn with a rook,
	261	// or anything but a queen with a queen,
	262	// or anything with a king.
	263	move.eval = hisPieceVal - myPieceVal;
	264	//Math.random() < 0.5 ? 1 : -1;
	265	}
	266	}
	267	}
	268
	269	// TODO: also need to implement the case when an opponent piece (in light)
	270	// is threatening something - maybe not the king, but e.g. pawn takes rook.
	271
	272	moves.sort((a, b) => b.eval - a.eval);
	273	let candidates = [0];
	274	for (let j = 1; j < moves.length && moves[j].eval == moves[0].eval; j++)
	275	candidates.push(j);
	276	return moves[candidates[randInt(candidates.length)]];
	277	}
	278
	279	};