Position & Chess

const pos = Chess.default();
pos.play({ from: 12, to: 28 }); // e2-e4
pos.reset(); // Back to starting position

const original = Chess.default();
const copy = original.clone();
copy.play({ from: 12, to: 28 }); // Doesn't affect original

const pos = Chess.default();
const ctx = pos.ctx();
if (ctx.checkers.nonEmpty()) {
  console.log('King is in check!');
}

const pos = Chess.default();
const e2Dests = pos.dests(12); // Square 12 is e2
for (const dest of e2Dests) {
  console.log(`Can move to square ${dest}`);
}

const pos = Crazyhouse.default();
if (pos.pockets && pos.pockets[pos.turn].pawn > 0) {
  const dropSquares = pos.dropDests();
  console.log(`Can drop pawn on ${dropSquares.size()} squares`);
}

const pos = Chess.default();
const allMoves = pos.allDests();
for (const [from, dests] of allMoves) {
  console.log(`Piece on ${from} can move to ${dests.size()} squares`);
}

const pos = Chess.default();
const e4Move = { from: 12, to: 28 };
if (pos.isLegal(e4Move)) {
  pos.play(e4Move);
}

const pos = Chess.default();
pos.play({ from: 12, to: 28 }); // e2-e4
pos.play({ from: 52, to: 36 }); // e7-e5
console.log(pos.turn); // 'white'

const pos = Chess.default();
if (pos.isCheck()) {
  console.log('You must move out of check!');
}

const pos = Chess.default();
if (pos.isCheckmate()) {
  console.log(`${opposite(pos.turn)} wins by checkmate!`);
}

const pos = Chess.default();
if (pos.isStalemate()) {
  console.log('Draw by stalemate');
}

const pos = Chess.default();
while (!pos.isEnd()) {
  // Game continues
}

const pos = Atomic.default();
if (pos.isVariantEnd()) {
  console.log('A king has been captured!');
}

const pos = Chess.default();
const result = pos.outcome();
if (result) {
  if (result.winner) {
    console.log(`${result.winner} wins!`);
  } else {
    console.log('Draw');
  }
}

const pos = Chess.default();
if (pos.hasInsufficientMaterial('white') && pos.hasInsufficientMaterial('black')) {
  console.log('Draw by insufficient material');
}

const pos = Chess.default();
if (pos.isInsufficientMaterial()) {
  console.log('Automatic draw');
}

const pos = Chess.default();
if (!pos.hasDests()) {
  console.log(pos.isCheck() ? 'Checkmate!' : 'Stalemate!');
}

const pos = Chess.default();
pos.play({ from: 12, to: 28 });
const setup = pos.toSetup();
// Can recreate position later with Chess.fromSetup(setup)

const pos = Chess.default();
const king = pos.board.kingOf('white');
if (king !== undefined) {
  const attackers = pos.kingAttackers(king, 'black', pos.board.occupied);
  console.log(`${attackers.size()} pieces attacking the king`);
}

const pos = Chess.default();
console.log(pos.turn); // 'white'
console.log(pos.fullmoves); // 1

import { Chess } from 'chessops';

const setup = {
  board: Board.default(),
  turn: 'white',
  castlingRights: SquareSet.corners(),
  epSquare: undefined,
  remainingChecks: undefined,
  halfmoves: 0,
  fullmoves: 1
};

const result = Chess.fromSetup(setup);
if (result.isOk) {
  const pos = result.value;
  console.log('Valid position created');
} else {
  console.error('Invalid setup:', result.error.message);
}

const original = Chess.default();
const copy = original.clone();
copy.play({ from: 12, to: 28 });
console.log(original.turn); // 'white' (unchanged)
console.log(copy.turn); // 'black'

const castles = Castles.default();
console.log(castles.rook.white.h); // 7 (h1 rook)

const castles = Castles.empty();
console.log(castles.castlingRights.isEmpty()); // true

const pos = Chess.default();
pos.castles.discardRook(7); // White loses kingside castling

const pos = Chess.default();
pos.castles.discardColor('white'); // White loses all castling

const pos = Chess.default();
const ctx = pos.ctx();

if (ctx.checkers.nonEmpty()) {
  console.log('In check from', ctx.checkers.size(), 'piece(s)');
}

if (ctx.blockers.has(someSquare)) {
  console.log('This piece is pinned to the king');
}

import { Chess, IllegalSetup, PositionError } from 'chessops';

const result = Chess.fromSetup(invalidSetup);
if (result.isErr) {
  const error = result.error;
  if (error.message === IllegalSetup.Kings) {
    console.log('Invalid number of kings');
  }
}

try {
  const result = Chess.fromSetup(setup);
  if (result.isErr) {
    throw result.error;
  }
} catch (error) {
  if (error instanceof PositionError) {
    console.error('Invalid position:', error.message);
  }
}

import { pseudoDests } from 'chessops';

const pos = Chess.default();
const ctx = pos.ctx();
const pseudo = pseudoDests(pos, 12, ctx); // e2 pawn moves

import { equalsIgnoreMoves } from 'chessops';

const pos1 = Chess.default();
const pos2 = Chess.default();
pos2.fullmoves = 10;

console.log(equalsIgnoreMoves(pos1, pos2)); // true

import { castlingSide } from 'chessops';

const pos = Chess.default();
const move = { from: 4, to: 6 }; // e1-g1
const side = castlingSide(pos, move);
if (side === 'h') {
  console.log('Kingside castle');
}

import { normalizeMove } from 'chessops';

const pos = Chess.default();
const move = { from: 4, to: 6 }; // e1-g1 (kingside castle)
const normalized = normalizeMove(pos, move);
// normalized.to is now 7 (h1 rook square)

import { isStandardMaterial } from 'chessops';

const pos = Chess.default();
console.log(isStandardMaterial(pos)); // true

import { isImpossibleCheck } from 'chessops';

const pos = Chess.fromSetup(suspiciousSetup).value;
if (isImpossibleCheck(pos)) {
  console.log('This position is invalid!');
}