Atomic Chess

import { Atomic } from 'chessops/variant';

// Create a new Atomic position
const pos = Atomic.default();

// Play a normal move
pos.play({ from: 12, to: 28 }); // e2-e4

// After a capture, pieces explode
pos.play({ from: 51, to: 35 }); // d7-d5
pos.play({ from: 28, to: 35 }); // e4xd5 - explosion!

// Check if game ended via explosion
if (pos.isVariantEnd()) {
  const outcome = pos.variantOutcome();
  console.log('Winner:', outcome?.winner);
}

// When a capture occurs:
// 1. The captured piece is removed
// 2. The capturing piece is removed
// 3. All non-pawn pieces in kingAttacks(square) are removed

const pos = Atomic.default();
pos.play({ from: 12, to: 28 }); // e2-e4
pos.play({ from: 51, to: 35 }); // d7-d5  
pos.play({ from: 28, to: 35 }); // e4xd5

// After exd5:
// - Pawn on e4 is destroyed (capturing piece)
// - Pawn on d5 is destroyed (captured piece)
// - All non-pawn pieces adjacent to d5 are destroyed
// - Pawns in the blast radius survive

protected playCaptureAt(square: Square, captured: Piece): void {
  super.playCaptureAt(square, captured);
  this.board.take(square);
  for (const explode of kingAttacks(square).intersect(this.board.occupied).diff(this.board.pawn)) {
    const piece = this.board.take(explode);
    if (piece?.role === 'rook') this.castles.discardRook(explode);
    if (piece?.role === 'king') this.castles.discardColor(piece.color);
  }
}

import { Atomic } from 'chessops/variant';

const pos = Atomic.default();

// Check if game ended via king explosion
if (pos.isVariantEnd()) {
  const outcome = pos.variantOutcome();
  
  if (outcome?.winner === 'white') {
    console.log('Black king exploded!');
  } else if (outcome?.winner === 'black') {
    console.log('White king exploded!');
  }
}

variantOutcome(_ctx?: Context): Outcome | undefined {
  for (const color of COLORS) {
    if (this.board.pieces(color, 'king').isEmpty()) {
      return { winner: opposite(color) };
    }
  }
  return;
}

const pos = Atomic.default();

// Kings cannot attack each other (would both explode)
// If kings are adjacent, kingAttackers returns empty

kingAttackers(square: Square, attacker: Color, occupied: SquareSet): SquareSet {
  const attackerKings = this.board.pieces(attacker, 'king');
  if (attackerKings.isEmpty() || kingAttacks(square).intersects(attackerKings)) {
    return SquareSet.empty();
  }
  return super.kingAttackers(square, attacker, occupied);
}

import { Atomic } from 'chessops/variant';
import { parseSquare } from 'chessops';

const pos = Atomic.default();
const square = parseSquare('e2')!;

// Get legal moves (accounts for explosions)
const dests = pos.dests(square);

// A move is legal if:
// 1. After the move, our king exists, AND
// 2. Either opponent's king is gone OR our king is not in check

dests(square: Square, ctx?: Context): SquareSet {
  ctx = ctx || this.ctx();
  let dests = SquareSet.empty();
  for (const to of pseudoDests(this, square, ctx)) {
    const after = this.clone();
    after.play({ from: square, to });
    const ourKing = after.board.kingOf(this.turn);
    if (
      defined(ourKing)
      && (!defined(after.board.kingOf(after.turn))
        || after.kingAttackers(ourKing, after.turn, after.board.occupied).isEmpty())
    ) {
      dests = dests.with(to);
    }
  }
  return dests;
}

import { Atomic } from 'chessops/variant';
import { parseFen } from 'chessops/fen';

const setup = parseFen(
  'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'
).unwrap();

const result = Atomic.fromSetup(setup);

if (result.isErr) {
  // Possible errors:
  // - Empty board
  // - More than 2 kings
  // - Opponent's king in check
  // - Pawns on backrank
}

protected validate(): Result<undefined, PositionError> {
  // Like chess, but allow our king to be missing.
  if (this.board.occupied.isEmpty()) 
    return Result.err(new PositionError(IllegalSetup.Empty));
  if (this.board.king.size() > 2) 
    return Result.err(new PositionError(IllegalSetup.Kings));
  const otherKing = this.board.kingOf(opposite(this.turn));
  if (!defined(otherKing)) 
    return Result.err(new PositionError(IllegalSetup.Kings));
  if (this.kingAttackers(otherKing, this.turn, this.board.occupied).nonEmpty()) {
    return Result.err(new PositionError(IllegalSetup.OppositeCheck));
  }
  if (SquareSet.backranks().intersects(this.board.pawn)) {
    return Result.err(new PositionError(IllegalSetup.PawnsOnBackrank));
  }
  return Result.ok(undefined);
}

const pos = Atomic.default();

const isInsufficient = pos.hasInsufficientMaterial('white');

// Insufficient material considers:
// - If enemy king is already exploded (always sufficient)
// - Bare king cannot mate
// - Enemy pieces can explode near their own king
// - Special cases for bishops on same color squares

import { Atomic } from 'chessops/variant';
import { parseSquare, makeFen } from 'chessops/fen';

// Start a game
const pos = Atomic.default();

console.log('Starting position:');
console.log(makeFen(pos.toSetup()));

// Play the Atomic Gambit
pos.play({ from: parseSquare('e2')!, to: parseSquare('e4')! });
pos.play({ from: parseSquare('e7')!, to: parseSquare('e5')! });
pos.play({ from: parseSquare('g1')!, to: parseSquare('f3')! });
pos.play({ from: parseSquare('f8')!, to: parseSquare('c5')! });
pos.play({ from: parseSquare('f3')!, to: parseSquare('e5')! }); // Capture!

// After Nxe5, explosion occurs:
// - Knight on f3 explodes (capturing piece)
// - Pawn on e5 explodes (captured piece)  
// - King on e8 might be in blast radius!

if (pos.isVariantEnd()) {
  console.log('Game over!');
  const outcome = pos.variantOutcome();
  console.log('Winner:', outcome?.winner);
} else {
  console.log('Game continues');
  console.log(makeFen(pos.toSetup()));
}

// Check legal moves for a piece
const e2 = parseSquare('e2')!;
const moves = pos.dests(e2);
console.log(`Pawn on e2 has ${moves.size()} legal moves`);

// Clone for analysis
const analysis = pos.clone();
for (const square of pos.board.occupied) {
  const dests = analysis.dests(square);
  if (dests.nonEmpty()) {
    console.log(`Piece on ${square} can move to ${dests.size()} squares`);
  }
}

// Normal chess: Cannot move into check
// Atomic: Can "move into check" if it captures enemy king

const pos = Atomic.default();
// ... setup position where capture explodes enemy king

const dests = pos.dests(square);
// May include moves that would be illegal in standard chess