Struct Bitboard 

#[repr(C, align(16))]
pub struct Bitboard {
    pub planes: [u16; 8],
}

128-bit bitboard: 8 planes of u16 for a 4×4 Quantik board.

Layout: [C0S0, C0S1, C0S2, C0S3, C1S0, C1S1, C1S2, C1S3] where C = color (0 = player 0, 1 = player 1) and S = shape (0..3 → A..D).

Fields

planes: [u16; 8]

Implementations

impl Bitboard

pub const EMPTY: Self

pub fn new(planes: [u16; 8]) -> Self

pub fn plane_index(player: u8, shape: u8) -> usize

pub fn occupied(&self) -> u16

pub fn is_position_occupied(&self, pos: u8) -> bool

pub fn with_move(&self, player: u8, shape: u8, position: u8) -> Self

Set one bit and return a new bitboard (functional style).

pub fn player_piece_count(&self, player: u8) -> u32

Total number of pieces for a given player.

pub fn shape_piece_count(&self, player: u8, shape: u8) -> u32

Piece count for a specific (player, shape) pair.

pub fn to_le_bytes(&self) -> [u8; 16]

Pack to 16 little-endian bytes.

Examples found in repository

examples/depth4_survey.rs (line 73)

fn enumerate_depth4() -> Vec<(Bitboard, u64)> {
    let mut frontier: HashMap<[u8; 16], (Bitboard, u64)> = HashMap::new();
    frontier.insert(Bitboard::EMPTY.to_le_bytes(), (Bitboard::EMPTY, 1));

    for _ply in 0..4 {
        let mut next: HashMap<[u8; 16], (Bitboard, u64)> = HashMap::new();
        for (bb, mult) in frontier.values() {
            for mv in generate_legal_moves(bb) {
                let child = apply_move(bb, &mv);
                if has_winning_line(&child) {
                    continue;
                }
                let canon = SymmetryHandler::find_canonical(&child);
                let key = canon.to_le_bytes();
                let entry = next.entry(key).or_insert((canon, 0));
                entry.1 += mult;
            }
        }
        frontier = next;
    }

    let mut states: Vec<(Bitboard, u64)> = frontier
        .into_values()
        .filter(|(bb, _)| !generate_legal_moves(bb).is_empty())
        .collect();
    states.sort_by_key(|(bb, _)| bb.to_le_bytes());
    states
}

fn main() {
    let args = parse_args();

    let started = Instant::now();
    let mut states = enumerate_depth4();
    println!(
        "enumerated {} canonical nonterminal depth-4 states in {:.2}s",
        states.len(),
        started.elapsed().as_secs_f64()
    );
    if args.sample > 0 && args.sample < states.len() {
        use rand::prelude::*;
        let mut rng = StdRng::seed_from_u64(args.seed);
        states.shuffle(&mut rng);
        states.truncate(args.sample);
        states.sort_by_key(|(bb, _)| bb.to_le_bytes());
        println!(
            "sampled {} of {} states (seed={})",
            states.len(),
            10946,
            args.seed
        );
    } else if args.limit > 0 {
        states.truncate(args.limit);
        println!("limited to {} states for this run", states.len());
    }

    let book = OpeningBookDatabase::open(&OpeningBookConfig {
        database_path: args.db.clone(),
        ..Default::default()
    })
    .expect("open book");

    let mut rows: Vec<serde_json::Value> = Vec::with_capacity(states.len());
    let mut solved = 0usize;
    let mut cutoff = 0usize;
    let solve_started = Instant::now();

    for (i, (bb, mult)) in states.iter().enumerate() {
        let t0 = Instant::now();
        let reference = solve_position_with_book(bb, args.budget_s, Some(&book));
        let elapsed = t0.elapsed().as_secs_f64();
        println!(
            "  [{}/{}] {} solved={} elapsed={:.3}s",
            i + 1,
            states.len(),
            State::new(*bb).to_qfen(),
            reference.is_some(),
            elapsed
        );

        match &reference {
            Some(r) => {
                solved += 1;
                rows.push(serde_json::json!({
                    "qfen": State::new(*bb).to_qfen(),
                    "multiplicity": mult,
                    "value": r["value"],
                    "nodes": r["nodes"],
                    "solve_time_s": elapsed,
                    "solver": r["solver"],
                }));
            }
            None => {
                cutoff += 1;
                rows.push(serde_json::json!({
                    "qfen": State::new(*bb).to_qfen(),
                    "multiplicity": mult,
                    "value": null,
                    "nodes": null,
                    "solve_time_s": elapsed,
                    "solver": null,
                }));
            }
        }

        if (i + 1) % 25 == 0 || i + 1 == states.len() {
            println!(
                "progress: {}/{} solved={} cutoff={} elapsed_total={:.1}s",
                i + 1,
                states.len(),
                solved,
                cutoff,
                solve_started.elapsed().as_secs_f64()
            );
            // Flush partial results after every progress line so a killed
            // run still leaves a readable, if incomplete, artifact — the
            // SQLite book itself is already durable per-row regardless.
            let partial = serde_json::json!({
                "budget_s": args.budget_s,
                "total_canonical_depth4_states": states.len(),
                "processed": i + 1,
                "solved": solved,
                "cutoff": cutoff,
                "positions": rows,
            });
            std::fs::write(&args.out, serde_json::to_string_pretty(&partial).unwrap())
                .expect("write partial output");
        }
    }

    println!(
        "done: {} solved, {} cutoff, total solve wall time {:.1}s -> {}",
        solved,
        cutoff,
        solve_started.elapsed().as_secs_f64(),
        args.out
    );
}

examples/depth_sweep.rs (line 23)

fn main() {
    let mut frontier: HashMap<[u8; 16], (Bitboard, u64)> = HashMap::new();
    frontier.insert(Bitboard::EMPTY.to_le_bytes(), (Bitboard::EMPTY, 1));

    println!(
        "depth,canonical_states,raw_boards,p0_wins_raw,p1_wins_raw,with_legal_moves,mean_orbit,min_orbit,max_orbit,elapsed_s"
    );

    for depth in 1..=16u32 {
        let started = Instant::now();
        let mut next: HashMap<[u8; 16], (Bitboard, u64)> = HashMap::new();
        let mut p0_wins_raw: u64 = 0;
        let mut p1_wins_raw: u64 = 0;

        for (bb, mult) in frontier.values() {
            for mv in generate_legal_moves(bb) {
                let child = apply_move(bb, &mv);
                if has_winning_line(&child) {
                    match check_winner(&child) {
                        WinStatus::Player0Wins => p0_wins_raw += mult,
                        WinStatus::Player1Wins => p1_wins_raw += mult,
                        WinStatus::NoWin => unreachable!(),
                    }
                    continue;
                }
                let canon = SymmetryHandler::find_canonical(&child);
                let key = canon.to_le_bytes();
                let entry = next.entry(key).or_insert((canon, 0));
                entry.1 += mult;
            }
        }
        frontier = next;

        let canonical_states = frontier.len();
        let raw_boards: u64 = frontier.values().map(|(_, m)| *m).sum();
        let with_moves = frontier
            .values()
            .filter(|(bb, _)| !generate_legal_moves(bb).is_empty())
            .count();

        let mut orbit_sizes: Vec<usize> = frontier
            .values()
            .map(|(bb, _)| SymmetryHandler::orbit_size(bb))
            .collect();
        orbit_sizes.sort_unstable();
        let mean = if orbit_sizes.is_empty() {
            0.0
        } else {
            orbit_sizes.iter().sum::<usize>() as f64 / orbit_sizes.len() as f64
        };
        let min = orbit_sizes.first().copied().unwrap_or(0);
        let max = orbit_sizes.last().copied().unwrap_or(0);

        // Per-depth orbit-size histogram, written alongside the summary line.
        let mut hist: BTreeMap<usize, u64> = BTreeMap::new();
        for bb in frontier.values() {
            *hist.entry(SymmetryHandler::orbit_size(&bb.0)).or_insert(0) += 1;
        }
        let hist_str: Vec<String> = hist.iter().map(|(s, c)| format!("{s}:{c}")).collect();

        println!(
            "{depth},{canonical_states},{raw_boards},{p0_wins_raw},{p1_wins_raw},{with_moves},{mean:.2},{min},{max},{:.3}",
            started.elapsed().as_secs_f64()
        );
        eprintln!("  depth {depth} orbit histogram: {}", hist_str.join(" "));

        if canonical_states == 0 {
            eprintln!("frontier empty at depth {depth} — every line of play has ended by here");
            break;
        }
        if with_moves == 0 {
            eprintln!("all depth-{depth} states are dead ends (no legal moves) — game always over by depth {}", depth + 1);
        }
    }
}

pub fn from_le_bytes(buf: &[u8; 16]) -> Self

Unpack from 16 little-endian bytes.

Trait Implementations

impl Clone for Bitboard

fn clone(&self) -> Bitboard

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Bitboard

impl Debug for Bitboard

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Bitboard

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Bitboard

impl Hash for Bitboard

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Bitboard

fn eq(&self, other: &Bitboard) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Bitboard