Chess

interface Piece {
  Color color();
  List<Square> legalMoves(Square from, Board board);
}

final class Square {
  final int file;
  final int rank;
}

interface MoveCommand {
  Square from();
  void execute(Board board);
  void undo(Board board);
}

class NormalMove implements MoveCommand {
  private final Square from;
  private final Square to;
  private Piece captured;
  public Square from() { return from; }
  public void execute(Board board) {
    captured = board.at(to).orElse(null);
    board.move(from, to);
  }
  public void undo(Board board) {
    board.move(to, from);
    if (captured != null) board.place(to, captured);
  }
}

class Board {
  Optional<Piece> at(Square s);
  boolean isAttacked(Square s, Color by);
  void move(Square from, Square to);
}

class Game {
  private final Board board;
  private final Deque<MoveCommand> history = new ArrayDeque<>();
  private Color side = Color.WHITE;

  void play(MoveCommand move) {
    Piece moving = board.at(move.from()).orElseThrow(IllegalMove::new);
    if (moving.color() != side) throw new IllegalMove();
    move.execute(board);
    if (board.kingInCheck(side)) {
      move.undo(board);
      throw new IllegalMove();
    }
    history.push(move);
    side = side.opposite();
  }

  void undo() {
    MoveCommand last = history.pop();
    last.undo(board);
    side = side.opposite();
  }
}