SquareSet

import { SquareSet } from 'chessops';

const squares = SquareSet.fromSquare(0).union(SquareSet.fromSquare(7));
console.log(squares.size()); // 2

const squares = new SquareSet(0xff, 0); // First rank

static fromSquare(square: Square): SquareSet

const e4 = SquareSet.fromSquare(28);

static fromRank(rank: number): SquareSet

const firstRank = SquareSet.fromRank(0);

static fromFile(file: number): SquareSet

const aFile = SquareSet.fromFile(0);

static empty(): SquareSet

const empty = SquareSet.empty();

static full(): SquareSet

const allSquares = SquareSet.full();

static corners(): SquareSet

const corners = SquareSet.corners();

static center(): SquareSet

const center = SquareSet.center();

static backranks(): SquareSet

const backranks = SquareSet.backranks();

static backrank(color: Color): SquareSet

const whiteBackrank = SquareSet.backrank('white'); // First rank
const blackBackrank = SquareSet.backrank('black'); // Eighth rank

static lightSquares(): SquareSet

const lightSquares = SquareSet.lightSquares();

static darkSquares(): SquareSet

const darkSquares = SquareSet.darkSquares();

complement(): SquareSet

const occupied = SquareSet.fromSquare(0);
const empty = occupied.complement();

xor(other: SquareSet): SquareSet

const a = SquareSet.fromSquare(0);
const b = SquareSet.fromSquare(1);
const result = a.xor(b); // Contains both squares

union(other: SquareSet): SquareSet

const a = SquareSet.fromSquare(0);
const b = SquareSet.fromSquare(1);
const both = a.union(b);

intersect(other: SquareSet): SquareSet

const whitePieces = board.white;
const pawns = board.pawn;
const whitePawns = whitePieces.intersect(pawns);

diff(other: SquareSet): SquareSet

const allSquares = SquareSet.full();
const occupied = board.occupied;
const empty = allSquares.diff(occupied);

intersects(other: SquareSet): boolean

if (lightSquares.intersects(bishops)) {
  console.log('Has light-squared bishop');
}

isDisjoint(other: SquareSet): boolean

if (whiteSquares.isDisjoint(blackSquares)) {
  console.log('No overlap');
}

supersetOf(other: SquareSet): boolean

if (occupied.supersetOf(whitePieces)) {
  console.log('All white pieces are on occupied squares');
}

subsetOf(other: SquareSet): boolean

if (whitePawns.subsetOf(whitePieces)) {
  console.log('Valid subset');
}

shr64(shift: number): SquareSet

const shifted = squares.shr64(8); // Shift down one rank

shl64(shift: number): SquareSet

const shifted = squares.shl64(8); // Shift up one rank

bswap64(): SquareSet

const swapped = squares.bswap64();

rbit64(): SquareSet

const reversed = squares.rbit64();

minus64(other: SquareSet): SquareSet

const result = a.minus64(b);

equals(other: SquareSet): boolean

if (set1.equals(set2)) {
  console.log('Sets are identical');
}

size(): number

const count = squares.size();

isEmpty(): boolean

if (squares.isEmpty()) {
  console.log('No squares in set');
}

nonEmpty(): boolean

if (squares.nonEmpty()) {
  console.log('Has squares');
}

has(square: Square): boolean

if (occupied.has(28)) {
  console.log('e4 is occupied');
}

moreThanOne(): boolean

if (squares.moreThanOne()) {
  console.log('Multiple squares present');
}

set(square: Square, on: boolean): SquareSet

const updated = squares.set(28, true); // Add e4
const removed = squares.set(28, false); // Remove e4

with(square: Square): SquareSet

const withE4 = squares.with(28);

without(square: Square): SquareSet

const withoutE4 = squares.without(28);

toggle(square: Square): SquareSet

const toggled = squares.toggle(28);

first(): Square | undefined

const firstSquare = squares.first();
if (firstSquare !== undefined) {
  console.log('First square:', firstSquare);
}

last(): Square | undefined

const lastSquare = squares.last();

singleSquare(): Square | undefined

const king = board.pieces('white', 'king').singleSquare();
if (king !== undefined) {
  console.log('White king is on square', king);
}

withoutFirst(): SquareSet

const rest = squares.withoutFirst();

[Symbol.iterator](): Iterator<Square>

for (const square of squares) {
  console.log(square);
}

// Or use spread operator
const squareArray = [...squares];

reversed(): Iterable<Square>

for (const square of squares.reversed()) {
  console.log(square);
}

import { SquareSet } from 'chessops';
import { attacks } from 'chessops/attacks';

const piece = { role: 'queen', color: 'white' };
const square = 28; // e4
const occupied = board.occupied;

const attacked = attacks(piece, square, occupied);
console.log(`Queen on e4 attacks ${attacked.size()} squares`);

const bishops = board.bishop;
const lightSquareBishops = bishops.intersect(SquareSet.lightSquares());
const darkSquareBishops = bishops.intersect(SquareSet.darkSquares());

console.log('Light bishops:', lightSquareBishops.size());
console.log('Dark bishops:', darkSquareBishops.size());

// Create a set of center files (c, d, e, f)
let center = SquareSet.empty();
for (let file = 2; file <= 5; file++) {
  center = center.union(SquareSet.fromFile(file));
}

// Find pieces in the center
const centerPieces = board.occupied.intersect(center);
console.log('Pieces in center:', centerPieces.size());

const pawns = board.pawn.intersect(board.white);
const promotableRank = SquareSet.fromRank(6);

for (const pawn of pawns) {
  if (promotableRank.has(pawn)) {
    console.log('Pawn ready to promote on square', pawn);
  }
}