Updated docs and tests

8 files changed, 1408 insertions, 1296 deletions

diff --git a/cli/src/perft.rs b/cli/src/perft.rs
index eba640e..535aec0 100644
--- a/cli/src/perft.rs
+++ b/cli/src/perft.rs
@@ -1,26 +1,26 @@
-use ai::{CheckersBitBoard, Move, PossibleMoves};

-use rayon::prelude::*;

-use std::fmt::{Display, Formatter};

-

-#[derive(Clone)]

-struct PerftResult {

-	result: Vec<(Move, usize)>,

-}

-

-pub fn positions(board: CheckersBitBoard, depth: usize) -> usize {

-	let moves = PossibleMoves::moves(board);

-

-	if depth == 0 {

-		1

-	} else {

-		let mut total = 0;

-

-		for current_move in moves {

-			// safety: we got this move out of the list of possible moves, so it's definitely valid

-			let board = unsafe { current_move.apply_to(board) };

-			total += positions(board, depth - 1);

-		}

-

-		total

-	}

-}

+use ai::{CheckersBitBoard, Move, PossibleMoves};
+use rayon::prelude::*;
+use std::fmt::{Display, Formatter};
+
+#[derive(Clone)]
+struct PerftResult {
+	result: Vec<(Move, usize)>,
+}
+
+pub fn positions(board: CheckersBitBoard, depth: usize) -> usize {
+	let moves = PossibleMoves::moves(board);
+
+	if depth == 0 {
+		1
+	} else {
+		let mut total = 0;
+
+		for current_move in moves {
+			// safety: we got this move out of the list of possible moves, so it's definitely valid
+			let board = unsafe { current_move.apply_to(board) };
+			total += positions(board, depth - 1);
+		}
+
+		total
+	}
+}
diff --git a/model/benches/bitboard.rs b/model/benches/bitboard.rs
index 231f860..f1dd9e1 100644
--- a/model/benches/bitboard.rs
+++ b/model/benches/bitboard.rs
@@ -1,96 +1,98 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};

-use model::CheckersBitBoard;

-use std::collections::hash_map::DefaultHasher;

-use std::hash::Hash;

-

-fn clone(c: &mut Criterion) {

-	let board = CheckersBitBoard::starting_position();

-	c.bench_function("clone", |b| b.iter(|| black_box(board.clone())));

-}

-

-fn hash(c: &mut Criterion) {

-	let board = CheckersBitBoard::starting_position();

-	let mut hasher = DefaultHasher::new();

-	c.bench_function("hash", |b| b.iter(|| board.hash(black_box(&mut hasher))));

-}

-

-fn default(c: &mut Criterion) {

-	c.bench_function("default", |b| {

-		b.iter(|| black_box(CheckersBitBoard::default()))

-	});

-}

-

-fn eq(c: &mut Criterion) {

-	let board1 = CheckersBitBoard::default();

-	let board2 = CheckersBitBoard::default();

-	c.bench_function("equal", |b| {

-		b.iter(|| black_box(board1) == black_box(board2))

-	});

-}

-

-fn default_const(c: &mut Criterion) {

-	c.bench_function("default (const)", |b| {

-		b.iter(|| black_box(CheckersBitBoard::starting_position()))

-	});

-}

-

-fn new(c: &mut Criterion) {

-	c.bench_function("new", |b| {

-		b.iter(|| CheckersBitBoard::new(black_box(7328), black_box(174), black_box(27590)))

-	});

-}

-

-fn piece_at(c: &mut Criterion) {

-	let board = CheckersBitBoard::starting_position();

-	c.bench_function("piece", |b| b.iter(|| board.piece_at(black_box(0))));

-}

-

-fn color_at_unchecked(c: &mut Criterion) {

-	let board = CheckersBitBoard::starting_position();

-	c.bench_function("color (unsafe)", |b| {

-		b.iter(|| unsafe { board.color_at_unchecked(black_box(1)) })

-	});

-}

-

-fn king_at_unchecked(c: &mut Criterion) {

-	let board = CheckersBitBoard::starting_position();

-	c.bench_function("king (unsafe)", |b| {

-		b.iter(|| unsafe { board.king_at_unchecked(black_box(2)) })

-	});

-}

-

-fn color_at(c: &mut Criterion) {

-	let board = CheckersBitBoard::starting_position();

-	c.bench_function("color (safe - filled)", |b| {

-		b.iter(|| board.color_at(black_box(3)))

-	});

-

-	c.bench_function("color (safe - empty)", |b| {

-		b.iter(|| board.color_at(black_box(2)))

-	});

-}

-

-fn king_at(c: &mut Criterion) {

-	let board = CheckersBitBoard::starting_position();

-	c.bench_function("king (safe - filled)", |b| {

-		b.iter(|| board.king_at(black_box(4)))

-	});

-

-	c.bench_function("king (safe - empty)", |b| {

-		b.iter(|| board.king_at(black_box(9)))

-	});

-}

-

-criterion_group!(

-	bitboard, clone,

-	          hash, eq,

-	          default,

-	          default_const,

-	          new,

-	          piece_at,

-	          color_at_unchecked,

-	          king_at_unchecked,

-	          color_at,

-	          king_at,

-);

-criterion_main!(bitboard);

+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use model::CheckersBitBoard;
+use std::collections::hash_map::DefaultHasher;
+use std::hash::Hash;
+
+fn clone(c: &mut Criterion) {
+	let board = CheckersBitBoard::starting_position();
+	c.bench_function("clone", |b| b.iter(|| black_box(board.clone())));
+}
+
+fn hash(c: &mut Criterion) {
+	let board = CheckersBitBoard::starting_position();
+	let mut hasher = DefaultHasher::new();
+	c.bench_function("hash", |b| b.iter(|| board.hash(black_box(&mut hasher))));
+}
+
+fn default(c: &mut Criterion) {
+	c.bench_function("default", |b| {
+		b.iter(|| black_box(CheckersBitBoard::default()))
+	});
+}
+
+fn eq(c: &mut Criterion) {
+	let board1 = CheckersBitBoard::default();
+	let board2 = CheckersBitBoard::default();
+	c.bench_function("equal", |b| {
+		b.iter(|| black_box(board1) == black_box(board2))
+	});
+}
+
+fn default_const(c: &mut Criterion) {
+	c.bench_function("default (const)", |b| {
+		b.iter(|| black_box(CheckersBitBoard::starting_position()))
+	});
+}
+
+fn new(c: &mut Criterion) {
+	c.bench_function("new", |b| {
+		b.iter(|| CheckersBitBoard::new(black_box(7328), black_box(174), black_box(27590)))
+	});
+}
+
+fn piece_at(c: &mut Criterion) {
+	let board = CheckersBitBoard::starting_position();
+	c.bench_function("piece", |b| b.iter(|| board.piece_at(black_box(0))));
+}
+
+fn color_at_unchecked(c: &mut Criterion) {
+	let board = CheckersBitBoard::starting_position();
+	c.bench_function("color (unsafe)", |b| {
+		b.iter(|| unsafe { board.color_at_unchecked(black_box(1)) })
+	});
+}
+
+fn king_at_unchecked(c: &mut Criterion) {
+	let board = CheckersBitBoard::starting_position();
+	c.bench_function("king (unsafe)", |b| {
+		b.iter(|| unsafe { board.king_at_unchecked(black_box(2)) })
+	});
+}
+
+fn color_at(c: &mut Criterion) {
+	let board = CheckersBitBoard::starting_position();
+	c.bench_function("color (safe - filled)", |b| {
+		b.iter(|| board.color_at(black_box(3)))
+	});
+
+	c.bench_function("color (safe - empty)", |b| {
+		b.iter(|| board.color_at(black_box(2)))
+	});
+}
+
+fn king_at(c: &mut Criterion) {
+	let board = CheckersBitBoard::starting_position();
+	c.bench_function("king (safe - filled)", |b| {
+		b.iter(|| board.king_at(black_box(4)))
+	});
+
+	c.bench_function("king (safe - empty)", |b| {
+		b.iter(|| board.king_at(black_box(9)))
+	});
+}
+
+criterion_group!(
+	bitboard,
+	clone,
+	hash,
+	eq,
+	default,
+	default_const,
+	new,
+	piece_at,
+	color_at_unchecked,
+	king_at_unchecked,
+	color_at,
+	king_at,
+);
+criterion_main!(bitboard);
diff --git a/model/src/board.rs b/model/src/board.rs
index 0128c89..75c29cb 100644
--- a/model/src/board.rs
+++ b/model/src/board.rs
@@ -1,589 +1,589 @@
-use crate::possible_moves::PossibleMoves;

-use crate::PieceColor;

-#[cfg(feature = "serde")]

-use serde::{Deserialize, Serialize};

-use std::hash::{Hash, Hasher};

-

-#[cfg(test)]

-mod tests;

-

-/// A checker board,

-/// organized in the following structure:

-/// ```txt

-///   11  05  31  25

-/// 10  04  30  24

-///   03  29  23  17

-/// 02  28  22  16

-///   27  21  15  09

-/// 26  20  14  08

-///   19  13  07  01

-/// 18  12  06  00

-/// ```

-#[derive(Copy, Clone, Debug, Eq)]

-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

-pub struct CheckersBitBoard {

-	/// If the space contains a piece, it's a 1

-	pieces: u32,

-	/// If the piece is black, 1, otherwise 0

-	color: u32,

-	/// 1 if the piece is a king

-	kings: u32,

-	/// The player who has the next turn

-	turn: PieceColor,

-}

-

-impl Default for CheckersBitBoard {

-	/// Returns the starting position

-	fn default() -> Self {

-		Self::starting_position()

-	}

-}

-

-impl PartialEq for CheckersBitBoard {

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

-		self.pieces == other.pieces

-			&& self.pieces & self.color == other.pieces & other.color

-			&& self.pieces & self.kings == other.pieces & other.kings

-			&& self.turn == other.turn

-	}

-}

-

-impl Hash for CheckersBitBoard {

-	/// Hashes with only the pieces part, to ensure correctness and efficiency

-	fn hash<H: Hasher>(&self, hasher: &mut H) {

-		self.pieces.hash(hasher)

-	}

-}

-

-impl CheckersBitBoard {

-	/// Creates a new Checkers BitBoard

-	///

-	/// # Arguments

-	///

-	/// * `pieces` - Each bit is 1 if the corresponding space contains a piece

-	/// * `color` - For each space with a piece, the value is 1 if it's dark, and 0 otherwise.

-	/// Bits for spaces without colors are undefined

-	/// * `kings` - For each space with a piece, the value is 1 if it's a king, and 0 otherwise.

-	/// Bits for spaces without colors are undefined

-	///

-	/// # Example

-	///

-	/// ```

-	/// // This is the starting position

-	/// use model::{CheckersBitBoard, PieceColor};

-	/// let board = CheckersBitBoard::new(0b11011111101111100111100111100111,

-	///                                   0b00111100001100001100001111001111,

-	///                                   0,

-	///                                   PieceColor::Dark);

-	/// ```

-	pub const fn new(pieces: u32, color: u32, kings: u32, turn: PieceColor) -> Self {

-		Self {

-			pieces,

-			color,

-			kings,

-			turn,

-		}

-	}

-

-	/// Creates a board at the starting position

-	pub const fn starting_position() -> Self {

-		const STARTING_BITBOARD: CheckersBitBoard = CheckersBitBoard::new(

-			0b11100111100111100111110111111011,

-			0b00001100001111001111001111000011,

-			0,

-			PieceColor::Dark,

-		);

-		STARTING_BITBOARD

-	}

-

-	/// Gets the bits that represent where pieces are on the board

-	pub const fn pieces_bits(self) -> u32 {

-		self.pieces

-	}

-

-	/// Gets the bits that represents the color of each piece on the board

-	///

-	/// # Safety

-	///

-	/// This is inherently unsafe, because this also returns the bits of empty squares

-	pub const fn color_bits(self) -> u32 {

-		self.color

-	}

-

-	/// Gets the bits that represents the status of each piece on the board

-	///

-	/// # Safety

-	///

-	/// This is inherently unsafe, because this also returns the bits of empty squares

-	pub const fn king_bits(self) -> u32 {

-		self.kings

-	}

-

-	/// The player whose turn it is

-	pub const fn turn(self) -> PieceColor {

-		self.turn

-	}

-

-	/// Checks if there's a piece at the given space value

-	///

-	/// # Arguments

-	///

-	/// * `value` - The value of the space to check

-	///

-	/// # Example

-	///

-	/// ```

-	/// use model::CheckersBitBoard;

-	/// let board = CheckersBitBoard::default();

-	/// match board.piece_at(0) {

-	///     true => println!("There's a piece in the bottom right"),

-	///     false => println!("The bottom right is empty")

-	/// }

-	/// ```

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	pub const fn piece_at(self, value: usize) -> bool {

-		((self.pieces >> value) & 1) == 1

-	}

-

-	/// Checks the color at the piece in the given location,

-	/// without checking if there's a piece there

-	///

-	/// # Arguments

-	///

-	/// * `value` - The value of the space to check

-	///

-	/// # Example

-	///

-	/// ```

-	/// use model::CheckersBitBoard;

-	/// use model::PieceColor;

-	/// let board = CheckersBitBoard::default();

-	/// if board.piece_at(0) {

-	///     match unsafe {board.color_at_unchecked(0)} {

-	///         PieceColor::Dark => println!("The piece in the bottom right is dark colored"),

-	///         PieceColor::Light => println!("The piece in the bottom right is light colored")

-	///     }

-	/// }

-	/// ```

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	///

-	/// # Safety

-	///

-	/// Checking the color at a square that is empty results in undefined behavior

-	pub const unsafe fn color_at_unchecked(self, value: usize) -> PieceColor {

-		if ((self.color >> value) & 1) != 0 {

-			PieceColor::Dark

-		} else {

-			PieceColor::Light

-		}

-	}

-

-	/// Checks the color at the piece in the given location.

-	/// Returns `None` if there isn't a piece there

-	///

-	/// # Arguments

-	///

-	/// * `value` - The value of the space to check

-	///

-	/// # Example

-	///

-	/// ```

-	/// use model::CheckersBitBoard;

-	/// use model::PieceColor;

-	/// let board = CheckersBitBoard::default();

-	/// if let Some(color) = board.color_at(0) {

-	///     match color {

-	///         PieceColor::Dark => println!("The piece in the bottom right is dark colored"),

-	///         PieceColor::Light => println!("The piece in the bottom left is light colored")

-	///     }

-	/// }

-	/// ```

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	pub const fn color_at(self, value: usize) -> Option<PieceColor> {

-		if self.piece_at(value) {

-			// safety: if this block runs, then it's already confirmed a piece exists here

-			Some(unsafe { self.color_at_unchecked(value) })

-		} else {

-			None

-		}

-	}

-

-	/// Checks if the given location has a king, without checking if there's a piece there

-	///

-	/// # Arguments

-	///

-	/// * `value` - The value of the space to check

-	///

-	/// # Example

-	///

-	/// ```

-	/// use model::CheckersBitBoard;

-	/// let board = CheckersBitBoard::default();

-	/// if board.piece_at(0) {

-	///     match unsafe {board.king_at_unchecked(0)} {

-	///         true => println!("The piece in the bottom right is a king"),

-	///         false => println!("The piece in the bottom right is a peasant")

-	///     }

-	/// }

-	/// ```

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	///

-	/// # Safety

-	///

-	/// Checking a square that is empty results in undefined behavior

-	pub const unsafe fn king_at_unchecked(self, value: usize) -> bool {

-		((self.kings >> value) & 1) == 1

-	}

-

-	/// Checks if the piece in the given location is a king.

-	/// Returns `None` if there isn't a piece there

-	///

-	/// # Arguments

-	///

-	/// * `value` - The value of the space to check

-	///

-	/// # Example

-	///

-	/// ```

-	/// use model::CheckersBitBoard;

-	/// let board = CheckersBitBoard::default();

-	/// if let Some(status) = board.king_at(0) {

-	///     match status {

-	///         true => println!("The piece in the bottom right is a king"),

-	///         false => println!("The piece in the bottom right is a peasant")

-	///     }

-	/// }

-	/// ```

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	pub const fn king_at(self, value: usize) -> Option<bool> {

-		if self.piece_at(value) {

-			// safety: if this block runs, then it's already confirmed a piece exists here

-			Some(unsafe { self.king_at_unchecked(value) })

-		} else {

-			None

-		}

-	}

-

-	pub const fn flip_turn(self) -> Self {

-		CheckersBitBoard::new(self.pieces, self.color, self.kings, self.turn.flip())

-	}

-

-	/// Moves a piece from `start` to `dest`. The original location will be empty.

-	/// This does not mutate the original board.

-	/// If a piece already exists at `dest`, it will be overwritten.

-	///

-	/// # Arguments

-	///

-	/// * `start` - The original location of the piece

-	/// * `dest` - The new location

-	///

-	/// # Panics

-	///

-	/// Panics if `start` or `dest` is greater than or equal to 32

-	///

-	/// # Safety

-	///

-	/// Results in undefined behavior if `start` does not contain a piece

-	pub const unsafe fn move_piece_to_unchecked(self, start: usize, dest: usize) -> Self {

-		// Clears the bit at the starting value

-		// Sets the bit at the destination value

-		let pieces = (self.pieces & !(1 << start)) | (1 << dest);

-

-		// Clears the bit at the destination value

-		// Sets the value at the destination to the value of the start

-		let color = (self.color & !(1 << dest)) | (((self.color >> start) & 1) << dest);

-

-		// The squares where certain pieces should be promoted

-		const DARK_PROMOTION_MASK: u32 = 0b10000010000000000000100000100000;

-		const LIGHT_PROMOTION_MASK: u32 = 0b1000001000001000001;

-

-		// Clears the bit at the destination value

-		// Sets the value at the destination to the value of the start

-		// Promotes if the end of the board was reached

-		let kings = (self.kings & !(1 << dest))

-			| (((self.kings >> start) & 1) << dest)

-			| (self.color & DARK_PROMOTION_MASK)

-			| (!self.color & LIGHT_PROMOTION_MASK);

-

-		let turn = self.turn.flip();

-

-		CheckersBitBoard::new(pieces, color, kings, turn)

-	}

-

-	/// Moves a piece from `value` to `(value + amount) % 32`. The original location will be empty.

-	/// This does not mutate the original board

-	///

-	/// # Arguments

-	///

-	/// * `value` - The original location of the piece

-	/// * `amount` - The amount to shift the location by

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32,

-	/// or `value + amount` is greater than `usize::MAX`

-	///

-	/// # Safety

-	///

-	/// This results in undefined behavior if `value` does not contain a piece

-	const unsafe fn move_piece_forward_unchecked(self, value: usize, amount: usize) -> Self {

-		self.move_piece_to_unchecked(value, (value + amount) & 31)

-	}

-

-	/// Moves a piece from `value` to `(value - amount) % 32`. The original location will be empty.

-	/// This does not mutate the original board.

-	/// If a piece already exists there, then it will be overwritten

-	///

-	/// # Arguments

-	///

-	/// * `value` - The original location of the piece

-	/// * `amount` - The amount to shift the location by

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	///

-	/// # Safety

-	///

-	/// This results in undefined behavior if `value` does not contain a piece

-	const unsafe fn move_piece_backward_unchecked(self, value: usize, amount: usize) -> Self {

-		self.move_piece_to_unchecked(value, value.wrapping_sub(amount) & 31)

-	}

-

-	/// Tries to move the piece forward and to the left, without checking if it's a legal move.

-	/// If a piece already exists there, then it will be overwritten

-	///

-	/// # Arguments

-	///

-	/// * `value` - The original location of the piece

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	///

-	/// # Safety

-	///

-	/// Moving from the left side of the board results in undefined behavior.

-	/// Moving from the top of the board results in undefined behavior.

-	/// A `value` which doesn't contain a piece results in undefined behavior.

-	pub const unsafe fn move_piece_forward_left_unchecked(self, value: usize) -> Self {

-		self.move_piece_forward_unchecked(value, 7)

-	}

-

-	/// Tries to move the piece forward and to the right, without checking if it's a legal move.

-	/// If a piece already exists there, then it will be overwritten

-	///

-	/// # Arguments

-	///

-	/// * `value` - The original location of the piece

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	///

-	/// # Safety

-	///

-	/// Moving from the right side of the board results in undefined behavior.

-	/// Moving from the top of the board results in undefined behavior.

-	/// A `value` which doesn't contain a piece results in undefined behavior.

-	pub const unsafe fn move_piece_forward_right_unchecked(self, value: usize) -> Self {

-		self.move_piece_forward_unchecked(value, 1)

-	}

-

-	/// Tries to move the piece backward and to the left, without checking if it's a legal move.

-	/// If a piece already exists there, then it will be overwritten

-	///

-	/// # Arguments

-	///

-	/// * `value` - The original location of the piece

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	///

-	/// # Safety

-	///

-	/// Moving from the left side of the board results in undefined behavior.

-	/// Moving from the bottom of the board results in undefined behavior.

-	/// A `value` which doesn't contain a piece results in undefined behavior.

-	pub const unsafe fn move_piece_backward_left_unchecked(self, value: usize) -> Self {

-		self.move_piece_backward_unchecked(value, 1)

-	}

-

-	/// Tries to move the piece backward and to the right, without checking if it's a legal move.

-	/// If a piece already exists there, then it will be overwritten

-	///

-	/// # Arguments

-	///

-	/// * `value` - The original location of the piece

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	///

-	/// # Safety

-	///

-	/// Moving from the right side of the board results in undefined behavior.

-	/// Moving from the bottom of the board results in undefined behavior.

-	/// A `value` which doesn't contain a piece results in undefined behavior.

-	pub const unsafe fn move_piece_backward_right_unchecked(self, value: usize) -> Self {

-		self.move_piece_backward_unchecked(value, 7)

-	}

-

-	/// Clears a space on the board. If the space is empty, then this function does nothing.

-	///

-	/// # Arguments

-	///

-	/// * `value` - The value of the space to clear

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	pub const fn clear_piece(self, value: usize) -> Self {

-		let pieces = self.pieces & !(1 << value);

-		CheckersBitBoard::new(pieces, self.color, self.kings, self.turn)

-	}

-

-	/// Tries to jump the piece forward and to the left, without checking if it's a legal move.

-	/// If a piece already exists there, then it will be overwritten.

-	/// The space the piece jumps over is cleared

-	///

-	/// # Arguments

-	///

-	/// * `value` - The original location of the piece

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	///

-	/// # Safety

-	///

-	/// Moving from the left side of the board results in undefined behavior.

-	/// Moving from the top of the board results in undefined behavior

-	pub const unsafe fn jump_piece_forward_left_unchecked(self, value: usize) -> Self {

-		let not_king = !self.king_at_unchecked(value);

-		let board = self

-			.move_piece_forward_unchecked(value, 14)

-			.clear_piece((value + 7) & 31);

-

-		const KING_MASK: u32 = 0b01000001000000000000010000010000;

-		if PossibleMoves::has_jumps(board.flip_turn())

-			&& not_king && (((1 << value) & KING_MASK) == 0)

-		{

-			board.flip_turn()

-		} else {

-			board

-		}

-	}

-

-	/// Tries to move the piece forward and to the right, without checking if it's a legal move.

-	/// If a piece already exists there, then it will be overwritten

-	/// The space the piece jumps over is cleared

-	///

-	/// # Arguments

-	///

-	/// * `value` - The original location of the piece

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	///

-	/// # Safety

-	///

-	/// Moving from the right side of the board results in undefined behavior.

-	/// Moving from the top of the board results in undefined behavior

-	pub const unsafe fn jump_piece_forward_right_unchecked(self, value: usize) -> Self {

-		let not_king = !self.king_at_unchecked(value);

-		let board = self

-			.move_piece_forward_unchecked(value, 2)

-			.clear_piece((value + 1) & 31);

-

-		const KING_MASK: u32 = 0b01000001000000000000010000010000;

-		if PossibleMoves::has_jumps(board.flip_turn())

-			&& not_king && (((1 << value) & KING_MASK) == 0)

-		{

-			board.flip_turn()

-		} else {

-			board

-		}

-	}

-

-	/// Tries to move the piece backward and to the left, without checking if it's a legal move.

-	/// If a piece already exists there, then it will be overwritten

-	/// The space the piece jumps over is cleared

-	///

-	/// # Arguments

-	///

-	/// * `value` - The original location of the piece

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	///

-	/// # Safety

-	///

-	/// Moving from the left side of the board results in undefined behavior.

-	/// Moving from the bottom of the board results in undefined behavior

-	pub const unsafe fn jump_piece_backward_left_unchecked(self, value: usize) -> Self {

-		let not_king = !self.king_at_unchecked(value);

-		let board = self

-			.move_piece_backward_unchecked(value, 2)

-			.clear_piece(value.wrapping_sub(1) & 31);

-

-		const KING_MASK: u32 = 0b00000000000010000010000010000010;

-		if PossibleMoves::has_jumps(board.flip_turn())

-			&& not_king && (((1 << value) & KING_MASK) == 0)

-		{

-			board.flip_turn()

-		} else {

-			board

-		}

-	}

-

-	/// Tries to move the piece backward and to the right, without checking if it's a legal move.

-	/// If a piece already exists there, then it will be overwritten

-	/// The space the piece jumps over is cleared

-	///

-	/// # Arguments

-	///

-	/// * `value` - The original location of the piece

-	///

-	/// # Panics

-	///

-	/// Panics if `value` is greater than or equal to 32

-	///

-	/// # Safety

-	///

-	/// Moving from the right side of the board results in undefined behavior.

-	/// Moving from the bottom of the board results in undefined behavior

-	pub const unsafe fn jump_piece_backward_right_unchecked(self, value: usize) -> Self {

-		let not_king = !self.king_at_unchecked(value);

-		let board = self

-			.move_piece_backward_unchecked(value, 14)

-			.clear_piece(value.wrapping_sub(7) & 31);

-

-		const KING_MASK: u32 = 0b00000000000010000010000010000010;

-		if PossibleMoves::has_jumps(board.flip_turn())

-			&& not_king && (((1 << value) & KING_MASK) == 0)

-		{

-			board.flip_turn()

-		} else {

-			board

-		}

-	}

-}

+use crate::possible_moves::PossibleMoves;
+use crate::PieceColor;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use std::hash::{Hash, Hasher};
+
+#[cfg(test)]
+mod tests;
+
+/// A checker board,
+/// organized in the following structure:
+/// ```txt
+///   11  05  31  25
+/// 10  04  30  24
+///   03  29  23  17
+/// 02  28  22  16
+///   27  21  15  09
+/// 26  20  14  08
+///   19  13  07  01
+/// 18  12  06  00
+/// ```
+#[derive(Copy, Clone, Debug, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct CheckersBitBoard {
+	/// If the space contains a piece, it's a 1
+	pieces: u32,
+	/// If the piece is black, 1, otherwise 0
+	color: u32,
+	/// 1 if the piece is a king
+	kings: u32,
+	/// The player who has the next turn
+	turn: PieceColor,
+}
+
+impl Default for CheckersBitBoard {
+	/// Returns the starting position
+	fn default() -> Self {
+		Self::starting_position()
+	}
+}
+
+impl PartialEq for CheckersBitBoard {
+	fn eq(&self, other: &Self) -> bool {
+		self.pieces == other.pieces
+			&& self.pieces & self.color == other.pieces & other.color
+			&& self.pieces & self.kings == other.pieces & other.kings
+			&& self.turn == other.turn
+	}
+}
+
+impl Hash for CheckersBitBoard {
+	/// Hashes with only the pieces part, to ensure correctness and efficiency
+	fn hash<H: Hasher>(&self, hasher: &mut H) {
+		self.pieces.hash(hasher)
+	}
+}
+
+impl CheckersBitBoard {
+	/// Creates a new Checkers BitBoard
+	///
+	/// # Arguments
+	///
+	/// * `pieces` - Each bit is 1 if the corresponding space contains a piece
+	/// * `color` - For each space with a piece, the value is 1 if it's dark, and 0 otherwise.
+	/// Bits for spaces without colors are undefined
+	/// * `kings` - For each space with a piece, the value is 1 if it's a king, and 0 otherwise.
+	/// Bits for spaces without colors are undefined
+	///
+	/// # Example
+	///
+	/// ```
+	/// // This is the starting position
+	/// use model::{CheckersBitBoard, PieceColor};
+	/// let board = CheckersBitBoard::new(0b11011111101111100111100111100111,
+	///                                   0b00111100001100001100001111001111,
+	///                                   0,
+	///                                   PieceColor::Dark);
+	/// ```
+	pub const fn new(pieces: u32, color: u32, kings: u32, turn: PieceColor) -> Self {
+		Self {
+			pieces,
+			color,
+			kings,
+			turn,
+		}
+	}
+
+	/// Creates a board at the starting position
+	pub const fn starting_position() -> Self {
+		const STARTING_BITBOARD: CheckersBitBoard = CheckersBitBoard::new(
+			0b11100111100111100111110111111011,
+			0b00001100001111001111001111000011,
+			0,
+			PieceColor::Dark,
+		);
+		STARTING_BITBOARD
+	}
+
+	/// Gets the bits that represent where pieces are on the board
+	pub const fn pieces_bits(self) -> u32 {
+		self.pieces
+	}
+
+	/// Gets the bits that represents the color of each piece on the board
+	///
+	/// # Safety
+	///
+	/// This is inherently unsafe, because this also returns the bits of empty squares
+	pub const fn color_bits(self) -> u32 {
+		self.color
+	}
+
+	/// Gets the bits that represents the status of each piece on the board
+	///
+	/// # Safety
+	///
+	/// This is inherently unsafe, because this also returns the bits of empty squares
+	pub const fn king_bits(self) -> u32 {
+		self.kings
+	}
+
+	/// The player whose turn it is
+	pub const fn turn(self) -> PieceColor {
+		self.turn
+	}
+
+	/// Checks if there's a piece at the given space value
+	///
+	/// # Arguments
+	///
+	/// * `value` - The value of the space to check
+	///
+	/// # Example
+	///
+	/// ```
+	/// use model::CheckersBitBoard;
+	/// let board = CheckersBitBoard::default();
+	/// match board.piece_at(0) {
+	///     true => println!("There's a piece in the bottom right"),
+	///     false => println!("The bottom right is empty")
+	/// }
+	/// ```
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	pub const fn piece_at(self, value: usize) -> bool {
+		((self.pieces >> value) & 1) == 1
+	}
+
+	/// Checks the color at the piece in the given location,
+	/// without checking if there's a piece there
+	///
+	/// # Arguments
+	///
+	/// * `value` - The value of the space to check
+	///
+	/// # Example
+	///
+	/// ```
+	/// use model::CheckersBitBoard;
+	/// use model::PieceColor;
+	/// let board = CheckersBitBoard::default();
+	/// if board.piece_at(0) {
+	///     match unsafe {board.color_at_unchecked(0)} {
+	///         PieceColor::Dark => println!("The piece in the bottom right is dark colored"),
+	///         PieceColor::Light => println!("The piece in the bottom right is light colored")
+	///     }
+	/// }
+	/// ```
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	///
+	/// # Safety
+	///
+	/// Checking the color at a square that is empty results in undefined behavior
+	pub const unsafe fn color_at_unchecked(self, value: usize) -> PieceColor {
+		if ((self.color >> value) & 1) != 0 {
+			PieceColor::Dark
+		} else {
+			PieceColor::Light
+		}
+	}
+
+	/// Checks the color at the piece in the given location.
+	/// Returns `None` if there isn't a piece there
+	///
+	/// # Arguments
+	///
+	/// * `value` - The value of the space to check
+	///
+	/// # Example
+	///
+	/// ```
+	/// use model::CheckersBitBoard;
+	/// use model::PieceColor;
+	/// let board = CheckersBitBoard::default();
+	/// if let Some(color) = board.color_at(0) {
+	///     match color {
+	///         PieceColor::Dark => println!("The piece in the bottom right is dark colored"),
+	///         PieceColor::Light => println!("The piece in the bottom left is light colored")
+	///     }
+	/// }
+	/// ```
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	pub const fn color_at(self, value: usize) -> Option<PieceColor> {
+		if self.piece_at(value) {
+			// safety: if this block runs, then it's already confirmed a piece exists here
+			Some(unsafe { self.color_at_unchecked(value) })
+		} else {
+			None
+		}
+	}
+
+	/// Checks if the given location has a king, without checking if there's a piece there
+	///
+	/// # Arguments
+	///
+	/// * `value` - The value of the space to check
+	///
+	/// # Example
+	///
+	/// ```
+	/// use model::CheckersBitBoard;
+	/// let board = CheckersBitBoard::default();
+	/// if board.piece_at(0) {
+	///     match unsafe {board.king_at_unchecked(0)} {
+	///         true => println!("The piece in the bottom right is a king"),
+	///         false => println!("The piece in the bottom right is a peasant")
+	///     }
+	/// }
+	/// ```
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	///
+	/// # Safety
+	///
+	/// Checking a square that is empty results in undefined behavior
+	pub const unsafe fn king_at_unchecked(self, value: usize) -> bool {
+		((self.kings >> value) & 1) == 1
+	}
+
+	/// Checks if the piece in the given location is a king.
+	/// Returns `None` if there isn't a piece there
+	///
+	/// # Arguments
+	///
+	/// * `value` - The value of the space to check
+	///
+	/// # Example
+	///
+	/// ```
+	/// use model::CheckersBitBoard;
+	/// let board = CheckersBitBoard::default();
+	/// if let Some(status) = board.king_at(0) {
+	///     match status {
+	///         true => println!("The piece in the bottom right is a king"),
+	///         false => println!("The piece in the bottom right is a peasant")
+	///     }
+	/// }
+	/// ```
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	pub const fn king_at(self, value: usize) -> Option<bool> {
+		if self.piece_at(value) {
+			// safety: if this block runs, then it's already confirmed a piece exists here
+			Some(unsafe { self.king_at_unchecked(value) })
+		} else {
+			None
+		}
+	}
+
+	pub const fn flip_turn(self) -> Self {
+		CheckersBitBoard::new(self.pieces, self.color, self.kings, self.turn.flip())
+	}
+
+	/// Moves a piece from `start` to `dest`. The original location will be empty.
+	/// This does not mutate the original board.
+	/// If a piece already exists at `dest`, it will be overwritten.
+	///
+	/// # Arguments
+	///
+	/// * `start` - The original location of the piece
+	/// * `dest` - The new location
+	///
+	/// # Panics
+	///
+	/// Panics if `start` or `dest` is greater than or equal to 32
+	///
+	/// # Safety
+	///
+	/// Results in undefined behavior if `start` does not contain a piece
+	pub const unsafe fn move_piece_to_unchecked(self, start: usize, dest: usize) -> Self {
+		// Clears the bit at the starting value
+		// Sets the bit at the destination value
+		let pieces = (self.pieces & !(1 << start)) | (1 << dest);
+
+		// Clears the bit at the destination value
+		// Sets the value at the destination to the value of the start
+		let color = (self.color & !(1 << dest)) | (((self.color >> start) & 1) << dest);
+
+		// The squares where certain pieces should be promoted
+		const DARK_PROMOTION_MASK: u32 = 0b10000010000000000000100000100000;
+		const LIGHT_PROMOTION_MASK: u32 = 0b1000001000001000001;
+
+		// Clears the bit at the destination value
+		// Sets the value at the destination to the value of the start
+		// Promotes if the end of the board was reached
+		let kings = (self.kings & !(1 << dest))
+			| (((self.kings >> start) & 1) << dest)
+			| (self.color & DARK_PROMOTION_MASK)
+			| (!self.color & LIGHT_PROMOTION_MASK);
+
+		let turn = self.turn.flip();
+
+		CheckersBitBoard::new(pieces, color, kings, turn)
+	}
+
+	/// Moves a piece from `value` to `(value + amount) % 32`. The original location will be empty.
+	/// This does not mutate the original board
+	///
+	/// # Arguments
+	///
+	/// * `value` - The original location of the piece
+	/// * `amount` - The amount to shift the location by
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32,
+	/// or `value + amount` is greater than `usize::MAX`
+	///
+	/// # Safety
+	///
+	/// This results in undefined behavior if `value` does not contain a piece
+	const unsafe fn move_piece_forward_unchecked(self, value: usize, amount: usize) -> Self {
+		self.move_piece_to_unchecked(value, (value + amount) & 31)
+	}
+
+	/// Moves a piece from `value` to `(value - amount) % 32`. The original location will be empty.
+	/// This does not mutate the original board.
+	/// If a piece already exists there, then it will be overwritten
+	///
+	/// # Arguments
+	///
+	/// * `value` - The original location of the piece
+	/// * `amount` - The amount to shift the location by
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	///
+	/// # Safety
+	///
+	/// This results in undefined behavior if `value` does not contain a piece
+	const unsafe fn move_piece_backward_unchecked(self, value: usize, amount: usize) -> Self {
+		self.move_piece_to_unchecked(value, value.wrapping_sub(amount) & 31)
+	}
+
+	/// Tries to move the piece forward and to the left, without checking if it's a legal move.
+	/// If a piece already exists there, then it will be overwritten
+	///
+	/// # Arguments
+	///
+	/// * `value` - The original location of the piece
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	///
+	/// # Safety
+	///
+	/// Moving from the left side of the board results in undefined behavior.
+	/// Moving from the top of the board results in undefined behavior.
+	/// A `value` which doesn't contain a piece results in undefined behavior.
+	pub const unsafe fn move_piece_forward_left_unchecked(self, value: usize) -> Self {
+		self.move_piece_forward_unchecked(value, 7)
+	}
+
+	/// Tries to move the piece forward and to the right, without checking if it's a legal move.
+	/// If a piece already exists there, then it will be overwritten
+	///
+	/// # Arguments
+	///
+	/// * `value` - The original location of the piece
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	///
+	/// # Safety
+	///
+	/// Moving from the right side of the board results in undefined behavior.
+	/// Moving from the top of the board results in undefined behavior.
+	/// A `value` which doesn't contain a piece results in undefined behavior.
+	pub const unsafe fn move_piece_forward_right_unchecked(self, value: usize) -> Self {
+		self.move_piece_forward_unchecked(value, 1)
+	}
+
+	/// Tries to move the piece backward and to the left, without checking if it's a legal move.
+	/// If a piece already exists there, then it will be overwritten
+	///
+	/// # Arguments
+	///
+	/// * `value` - The original location of the piece
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	///
+	/// # Safety
+	///
+	/// Moving from the left side of the board results in undefined behavior.
+	/// Moving from the bottom of the board results in undefined behavior.
+	/// A `value` which doesn't contain a piece results in undefined behavior.
+	pub const unsafe fn move_piece_backward_left_unchecked(self, value: usize) -> Self {
+		self.move_piece_backward_unchecked(value, 1)
+	}
+
+	/// Tries to move the piece backward and to the right, without checking if it's a legal move.
+	/// If a piece already exists there, then it will be overwritten
+	///
+	/// # Arguments
+	///
+	/// * `value` - The original location of the piece
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	///
+	/// # Safety
+	///
+	/// Moving from the right side of the board results in undefined behavior.
+	/// Moving from the bottom of the board results in undefined behavior.
+	/// A `value` which doesn't contain a piece results in undefined behavior.
+	pub const unsafe fn move_piece_backward_right_unchecked(self, value: usize) -> Self {
+		self.move_piece_backward_unchecked(value, 7)
+	}
+
+	/// Clears a space on the board. If the space is empty, then this function does nothing.
+	///
+	/// # Arguments
+	///
+	/// * `value` - The value of the space to clear
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	pub const fn clear_piece(self, value: usize) -> Self {
+		let pieces = self.pieces & !(1 << value);
+		CheckersBitBoard::new(pieces, self.color, self.kings, self.turn)
+	}
+
+	/// Tries to jump the piece forward and to the left, without checking if it's a legal move.
+	/// If a piece already exists there, then it will be overwritten.
+	/// The space the piece jumps over is cleared
+	///
+	/// # Arguments
+	///
+	/// * `value` - The original location of the piece
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	///
+	/// # Safety
+	///
+	/// Moving from the left side of the board results in undefined behavior.
+	/// Moving from the top of the board results in undefined behavior
+	pub const unsafe fn jump_piece_forward_left_unchecked(self, value: usize) -> Self {
+		let not_king = !self.king_at_unchecked(value);
+		let board = self
+			.move_piece_forward_unchecked(value, 14)
+			.clear_piece((value + 7) & 31);
+
+		const KING_MASK: u32 = 0b01000001000000000000010000010000;
+		if PossibleMoves::has_jumps(board.flip_turn())
+			&& not_king && (((1 << value) & KING_MASK) == 0)
+		{
+			board.flip_turn()
+		} else {
+			board
+		}
+	}
+
+	/// Tries to move the piece forward and to the right, without checking if it's a legal move.
+	/// If a piece already exists there, then it will be overwritten
+	/// The space the piece jumps over is cleared
+	///
+	/// # Arguments
+	///
+	/// * `value` - The original location of the piece
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	///
+	/// # Safety
+	///
+	/// Moving from the right side of the board results in undefined behavior.
+	/// Moving from the top of the board results in undefined behavior
+	pub const unsafe fn jump_piece_forward_right_unchecked(self, value: usize) -> Self {
+		let not_king = !self.king_at_unchecked(value);
+		let board = self
+			.move_piece_forward_unchecked(value, 2)
+			.clear_piece((value + 1) & 31);
+
+		const KING_MASK: u32 = 0b01000001000000000000010000010000;
+		if PossibleMoves::has_jumps(board.flip_turn())
+			&& not_king && (((1 << value) & KING_MASK) == 0)
+		{
+			board.flip_turn()
+		} else {
+			board
+		}
+	}
+
+	/// Tries to move the piece backward and to the left, without checking if it's a legal move.
+	/// If a piece already exists there, then it will be overwritten
+	/// The space the piece jumps over is cleared
+	///
+	/// # Arguments
+	///
+	/// * `value` - The original location of the piece
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	///
+	/// # Safety
+	///
+	/// Moving from the left side of the board results in undefined behavior.
+	/// Moving from the bottom of the board results in undefined behavior
+	pub const unsafe fn jump_piece_backward_left_unchecked(self, value: usize) -> Self {
+		let not_king = !self.king_at_unchecked(value);
+		let board = self
+			.move_piece_backward_unchecked(value, 2)
+			.clear_piece(value.wrapping_sub(1) & 31);
+
+		const KING_MASK: u32 = 0b00000000000010000010000010000010;
+		if PossibleMoves::has_jumps(board.flip_turn())
+			&& not_king && (((1 << value) & KING_MASK) == 0)
+		{
+			board.flip_turn()
+		} else {
+			board
+		}
+	}
+
+	/// Tries to move the piece backward and to the right, without checking if it's a legal move.
+	/// If a piece already exists there, then it will be overwritten
+	/// The space the piece jumps over is cleared
+	///
+	/// # Arguments
+	///
+	/// * `value` - The original location of the piece
+	///
+	/// # Panics
+	///
+	/// Panics if `value` is greater than or equal to 32
+	///
+	/// # Safety
+	///
+	/// Moving from the right side of the board results in undefined behavior.
+	/// Moving from the bottom of the board results in undefined behavior
+	pub const unsafe fn jump_piece_backward_right_unchecked(self, value: usize) -> Self {
+		let not_king = !self.king_at_unchecked(value);
+		let board = self
+			.move_piece_backward_unchecked(value, 14)
+			.clear_piece(value.wrapping_sub(7) & 31);
+
+		const KING_MASK: u32 = 0b00000000000010000010000010000010;
+		if PossibleMoves::has_jumps(board.flip_turn())
+			&& not_king && (((1 << value) & KING_MASK) == 0)
+		{
+			board.flip_turn()
+		} else {
+			board
+		}
+	}
+}
diff --git a/model/src/board/tests.rs b/model/src/board/tests.rs
index 2afe1da..0de12d5 100644
--- a/model/src/board/tests.rs
+++ b/model/src/board/tests.rs
@@ -538,6 +538,7 @@ fn test_move_piece_to_default_board() {
 	assert!(board.piece_at(5));
 	assert_eq!(board.color_at(5).unwrap(), PieceColor::Light);
 	assert!(!board.king_at(5).unwrap());
+	assert_eq!(board.turn, PieceColor::Light);
 }
 
 #[test]
@@ -548,6 +549,7 @@ fn test_move_piece_forward_standard() {
 	assert!(board.piece_at(16));
 	assert_eq!(board.color_at(16).unwrap(), PieceColor::Light);
 	assert!(!board.king_at(16).unwrap());
+	assert_eq!(board.turn, PieceColor::Light);
 }
 
 #[test]
@@ -558,6 +560,21 @@ fn test_move_piece_forward_wrap() {
 	assert!(board.piece_at(9));
 	assert_eq!(board.color_at(9).unwrap(), PieceColor::Dark);
 	assert!(!board.king_at(9).unwrap());
+	assert_eq!(board.turn, PieceColor::Light);
+}
+
+#[test]
+fn test_move_piece_forward_left_to_king() {
+	let board = CheckersBitBoard::new(0b10000, 0b10000, 0, PieceColor::Dark);
+	let board = unsafe { board.move_piece_forward_left_unchecked(4) };
+	assert!(board.king_at(5));
+}
+
+#[test]
+fn test_move_piece_backward_left_to_king() {
+	let board = CheckersBitBoard::new(0b10, 0, 0, PieceColor::Dark);
+	let board = unsafe { board.move_piece_backward_left_unchecked(1) };
+	assert!(board.king_at(0));
 }
 
 #[test]
@@ -568,6 +585,7 @@ fn test_move_piece_backward_standard() {
 	assert!(board.piece_at(15));
 	assert_eq!(board.color_at(15).unwrap(), PieceColor::Dark);
 	assert!(!board.king_at(15).unwrap());
+	assert_eq!(board.turn, PieceColor::Light);
 }
 
 #[test]
@@ -578,6 +596,7 @@ fn test_move_piece_backward_wrap() {
 	assert!(board.piece_at(28));
 	assert_eq!(board.color_at(28).unwrap(), PieceColor::Light);
 	assert!(!board.king_at(28).unwrap());
+	assert_eq!(board.turn, PieceColor::Light);
 }
 
 #[test]
@@ -596,6 +615,7 @@ fn test_jump_forward_left_specific() {
 	assert!(board2.piece_at(14));
 	assert_eq!(board2.color_at(14).unwrap(), board.color_at(0).unwrap());
 	assert_eq!(board2.king_at(14).unwrap(), board.king_at(0).unwrap());
+	assert_eq!(board.turn, PieceColor::Light);
 }
 
 #[test]
@@ -613,6 +633,7 @@ fn test_jump_forward_right_specific() {
 	assert!(board2.piece_at(20));
 	assert_eq!(board2.color_at(20).unwrap(), board.color_at(18).unwrap());
 	assert_eq!(board2.king_at(20).unwrap(), board.king_at(18).unwrap());
+	assert_eq!(board.turn, PieceColor::Light);
 }
 
 #[test]
@@ -630,6 +651,7 @@ fn test_jump_backward_left_specific() {
 	assert!(board2.piece_at(23));
 	assert_eq!(board2.color_at(23).unwrap(), board.color_at(25).unwrap());
 	assert_eq!(board2.king_at(23).unwrap(), board.king_at(25).unwrap());
+	assert_eq!(board.turn, PieceColor::Light);
 }
 
 #[test]
@@ -647,6 +669,7 @@ fn test_jump_backward_right_specific() {
 	assert!(board2.piece_at(29));
 	assert_eq!(board2.color_at(29).unwrap(), board.color_at(11).unwrap());
 	assert_eq!(board2.king_at(29).unwrap(), board.king_at(11).unwrap());
+	assert_eq!(board.turn, PieceColor::Light);
 }
 
 #[test]
diff --git a/model/src/color.rs b/model/src/color.rs
index 3dd2a64..c223c11 100644
--- a/model/src/color.rs
+++ b/model/src/color.rs
@@ -1,57 +1,94 @@
-#[cfg(feature = "serde")]

-use serde::{Deserialize, Serialize};

-use std::fmt::Display;

-

-/// The color of a piece

-#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]

-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

-pub enum PieceColor {

-	Light,

-	Dark,

-}

-

-impl Display for PieceColor {

-	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

-		write!(

-			f,

-			"{}",

-			match self {

-				Self::Light => "Light",

-				Self::Dark => "Dark",

-			}

-		)

-	}

-}

-

-impl PieceColor {

-	pub const fn flip(self) -> Self {

-		// TODO optimize

-		match self {

-			PieceColor::Light => PieceColor::Dark,

-			PieceColor::Dark => PieceColor::Light,

-		}

-	}

-

-	pub const fn flip_if(self, statement: bool) -> Self {

-		if statement {

-			self.flip()

-		} else {

-			self

-		}

-	}

-}

-

-#[cfg(test)]

-mod tests {

-	use super::*;

-

-	#[test]

-	fn light_display() {

-		assert_eq!(PieceColor::Light.to_string(), "Light");

-	}

-

-	#[test]

-	fn dark_display() {

-		assert_eq!(PieceColor::Dark.to_string(), "Dark");

-	}

-}

+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use std::fmt::Display;
+
+/// The color of a piece
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum PieceColor {
+	Light,
+	Dark,
+}
+
+impl Display for PieceColor {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(
+			f,
+			"{}",
+			match self {
+				Self::Light => "Light",
+				Self::Dark => "Dark",
+			}
+		)
+	}
+}
+
+impl PieceColor {
+	/// Flips the color
+	pub const fn flip(self) -> Self {
+		// TODO optimize
+		match self {
+			PieceColor::Light => PieceColor::Dark,
+			PieceColor::Dark => PieceColor::Light,
+		}
+	}
+
+	/// Flips the color if the statement is true
+	///
+	/// # Arguments
+	///
+	/// * `statement` - Flips the color if true
+	pub const fn flip_if(self, statement: bool) -> Self {
+		if statement {
+			self.flip()
+		} else {
+			self
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn light_display() {
+		assert_eq!(PieceColor::Light.to_string(), "Light");
+	}
+
+	#[test]
+	fn dark_display() {
+		assert_eq!(PieceColor::Dark.to_string(), "Dark");
+	}
+
+	#[test]
+	fn flip() {
+		let light = PieceColor::Light;
+		let dark = PieceColor::Dark;
+		assert_eq!(light.flip(), dark);
+		assert_eq!(dark.flip(), light);
+	}
+
+	#[test]
+	fn flip_if() {
+		let light = PieceColor::Light;
+		let dark = PieceColor::Dark;
+
+		assert_eq!(light.flip_if(true), dark);
+		assert_eq!(light.flip_if(false), light);
+		assert_eq!(dark.flip_if(true), light);
+		assert_eq!(dark.flip_if(false), dark);
+	}
+
+	#[test]
+	fn test_send() {
+		fn assert_send<T: Send>() {}
+		assert_send::<PieceColor>();
+	}
+
+	#[test]
+	fn test_sync() {
+		fn assert_sync<T: Sync>() {}
+		assert_sync::<PieceColor>();
+	}
+}
diff --git a/model/src/moves.rs b/model/src/moves.rs
index 30024d6..626d85a 100644
--- a/model/src/moves.rs
+++ b/model/src/moves.rs
@@ -1,59 +1,89 @@
-use crate::CheckersBitBoard;

-

-#[derive(Copy, Clone, Eq, PartialEq)]

-pub enum MoveDirection {

-	ForwardLeft = 0,

-	ForwardRight = 1,

-	BackwardLeft = 2,

-	BackwardRight = 3,

-}

-

-#[derive(Copy, Clone)]

-pub struct Move {

-	start: u32,

-	direction: MoveDirection,

-	jump: bool,

-}

-

-impl Move {

-	pub const fn new(start: usize, direction: MoveDirection, jump: bool) -> Self {

-		Self {

-			start: start as u32,

-			direction,

-			jump,

-		}

-	}

-

-	pub const unsafe fn apply_to(self, board: CheckersBitBoard) -> CheckersBitBoard {

-		match self.jump {

-			false => match self.direction {

-				MoveDirection::ForwardLeft => {

-					board.move_piece_forward_left_unchecked(self.start as usize)

-				}

-				MoveDirection::ForwardRight => {

-					board.move_piece_forward_right_unchecked(self.start as usize)

-				}

-				MoveDirection::BackwardLeft => {

-					board.move_piece_backward_left_unchecked(self.start as usize)

-				}

-				MoveDirection::BackwardRight => {

-					board.move_piece_backward_right_unchecked(self.start as usize)

-				}

-			},

-			true => match self.direction {

-				MoveDirection::ForwardLeft => {

-					board.jump_piece_forward_left_unchecked(self.start as usize)

-				}

-				MoveDirection::ForwardRight => {

-					board.jump_piece_forward_right_unchecked(self.start as usize)

-				}

-				MoveDirection::BackwardLeft => {

-					board.jump_piece_backward_left_unchecked(self.start as usize)

-				}

-				MoveDirection::BackwardRight => {

-					board.jump_piece_backward_right_unchecked(self.start as usize)

-				}

-			},

-		}

-	}

-}

+use crate::CheckersBitBoard;
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub enum MoveDirection {
+	ForwardLeft = 0,
+	ForwardRight = 1,
+	BackwardLeft = 2,
+	BackwardRight = 3,
+}
+
+/// A checkers move
+#[derive(Copy, Clone)]
+pub struct Move {
+	/// The position of the piece to move
+	start: u32,
+
+	/// The direction to move to
+	direction: MoveDirection,
+
+	/// Whether or not it's a jump
+	jump: bool,
+}
+
+impl Move {
+	/// Create a new move
+	///
+	/// # Arguments
+	///
+	/// * `start` - The location of the piece that should move
+	/// * `direction` - The direction the piece should move in
+	/// * `jump` - Whether or not the piece should jump
+	pub const fn new(start: usize, direction: MoveDirection, jump: bool) -> Self {
+		Self {
+			start: start as u32,
+			direction,
+			jump,
+		}
+	}
+
+	/// Apply the move to a board. This does not mutate the original board,
+	/// but instead returns a new one.
+	///
+	/// # Arguments
+	///
+	/// * `board` - The board to apply the move to
+	///
+	/// # Panics
+	///
+	/// Panics if the starting position of this move is greater than or equal to 32
+	///
+	/// # Safety
+	///
+	/// Applying an illegal move to the board is undefined behavior.
+	/// This functions results in undefined behavior if:
+	/// * The piece moves in a direction which would move it outside of the board
+	/// * The starting position of this move doesn't contain a piece
+	pub const unsafe fn apply_to(self, board: CheckersBitBoard) -> CheckersBitBoard {
+		match self.jump {
+			false => match self.direction {
+				MoveDirection::ForwardLeft => {
+					board.move_piece_forward_left_unchecked(self.start as usize)
+				}
+				MoveDirection::ForwardRight => {
+					board.move_piece_forward_right_unchecked(self.start as usize)
+				}
+				MoveDirection::BackwardLeft => {
+					board.move_piece_backward_left_unchecked(self.start as usize)
+				}
+				MoveDirection::BackwardRight => {
+					board.move_piece_backward_right_unchecked(self.start as usize)
+				}
+			},
+			true => match self.direction {
+				MoveDirection::ForwardLeft => {
+					board.jump_piece_forward_left_unchecked(self.start as usize)
+				}
+				MoveDirection::ForwardRight => {
+					board.jump_piece_forward_right_unchecked(self.start as usize)
+				}
+				MoveDirection::BackwardLeft => {
+					board.jump_piece_backward_left_unchecked(self.start as usize)
+				}
+				MoveDirection::BackwardRight => {
+					board.jump_piece_backward_right_unchecked(self.start as usize)
+				}
+			},
+		}
+	}
+}
diff --git a/model/src/moves_iter.rs b/model/src/moves_iter.rs
index 307ee96..ffa59b6 100644
--- a/model/src/moves_iter.rs
+++ b/model/src/moves_iter.rs
@@ -1,143 +1,144 @@
-use crate::moves::{Move, MoveDirection};

-use crate::possible_moves::PossibleMoves;

-

-const FORWARD_LEFT_SLIDE_SQUARES: [usize; 33] = [

-	1, 3, 3, 4, 6, 6, 7, 8, 9, 12, 12, 12, 13, 14, 15, 16, 17, 19, 19, 20, 21, 22, 23, 24, 27, 27,

-	27, 28, 29, 30, 32, 32, 32,

-];

-const FORWARD_RIGHT_SLIDE_SQUARES: [usize; 33] = [

-	2, 2, 3, 4, 6, 6, 7, 8, 10, 10, 12, 12, 13, 14, 15, 16, 18, 18, 19, 20, 21, 22, 23, 24, 26, 26,

-	27, 28, 29, 30, 32, 32, 32,

-];

-const BACKWARD_LEFT_SLIDE_SQUARES: [usize; 33] = [

-	1, 3, 3, 4, 5, 7, 7, 8, 9, 11, 11, 13, 13, 14, 15, 16, 17, 19, 19, 20, 21, 22, 23, 24, 25, 27,

-	27, 28, 29, 30, 31, 32, 32,

-];

-const BACKWARD_RIGHT_SLIDE_SQUARES: [usize; 33] = [

-	2, 2, 3, 4, 5, 7, 7, 8, 10, 10, 11, 13, 13, 14, 15, 16, 19, 19, 19, 20, 21, 22, 23, 24, 26, 26,

-	27, 28, 29, 30, 31, 32, 32,

-];

-

-const FORWARD_LEFT_JUMP_SQUARES: [usize; 33] = [

-	1, 6, 6, 6, 6, 6, 7, 8, 9, 12, 12, 12, 13, 14, 15, 16, 17, 20, 20, 20, 21, 22, 23, 28, 28, 28,

-	28, 28, 29, 32, 32, 32, 32,

-];

-const FORWARD_RIGHT_JUMP_SQUARES: [usize; 33] = [

-	2, 2, 3, 6, 6, 6, 7, 12, 12, 12, 12, 12, 13, 14, 15, 18, 18, 18, 19, 20, 21, 22, 23, 26, 26,

-	26, 27, 28, 29, 32, 32, 32, 32,

-];

-const BACKWARD_LEFT_JUMP_SQUARES: [usize; 33] = [

-	4, 4, 4, 4, 5, 8, 8, 8, 9, 14, 14, 14, 14, 14, 15, 16, 17, 20, 20, 20, 21, 22, 23, 24, 25, 28,

-	28, 28, 29, 30, 31, 32, 32,

-];

-const BACKWARD_RIGHT_JUMP_SQUARES: [usize; 33] = [

-	2, 2, 3, 4, 5, 10, 10, 10, 10, 10, 11, 14, 14, 14, 15, 20, 20, 20, 20, 20, 21, 22, 23, 26, 26,

-	26, 27, 28, 29, 30, 31, 32, 32,

-];

-

-static SLIDE_ARRAYS: [[usize; 33]; 4] = [

-	FORWARD_LEFT_SLIDE_SQUARES,

-	FORWARD_RIGHT_SLIDE_SQUARES,

-	BACKWARD_LEFT_SLIDE_SQUARES,

-	BACKWARD_RIGHT_SLIDE_SQUARES,

-];

-

-static JUMP_ARRAYS: [[usize; 33]; 4] = [

-	FORWARD_LEFT_JUMP_SQUARES,

-	FORWARD_RIGHT_JUMP_SQUARES,

-	BACKWARD_LEFT_JUMP_SQUARES,

-	BACKWARD_RIGHT_JUMP_SQUARES,

-];

-

-pub struct PossibleMovesIter {

-	possible_moves: PossibleMoves,

-	current_square: usize,

-	current_direction: MoveDirection,

-	movers: u32,

-	squares: &'static [usize; 33],

-}

-

-impl From<PossibleMoves> for PossibleMovesIter {

-	fn from(possible_moves: PossibleMoves) -> Self {

-		Self {

-			possible_moves,

-			current_square: 0,

-			current_direction: MoveDirection::ForwardLeft,

-			movers: possible_moves.forward_left_bits(),

-			squares: unsafe {

-				if possible_moves.can_jump() {

-					JUMP_ARRAYS.get_unchecked(0)

-				} else {

-					SLIDE_ARRAYS.get_unchecked(0)

-				}

-			},

-		}

-	}

-}

-

-impl Iterator for PossibleMovesIter {

-	type Item = Move;

-

-	fn next(&mut self) -> Option<Self::Item> {

-		loop {

-			if self.current_square == 32 {

-				if self.current_direction != MoveDirection::BackwardRight {

-					self.current_square = 0;

-					// safety: only results in undefined variant if equal to backward right

-					// this has already been checked for

-					self.current_direction =

-						unsafe { std::mem::transmute((self.current_direction as u8) + 1) };

-					self.movers = self

-						.possible_moves

-						.get_direction_bits(self.current_direction);

-

-					// safety: the max value of the enum is 3

-					unsafe {

-						self.squares = &*(self.squares as *const [usize; 33]).add(1);

-					}

-				} else {

-					return None;

-				}

-			}

-

-			if (self.movers >> self.current_square) & 1 != 0 {

-				let next_move = Move::new(

-					self.current_square,

-					self.current_direction,

-					self.possible_moves.can_jump(),

-				);

-

-				// safety: self.current_square will never be > 32

-				// squares does not contain such a value

-				unsafe {

-					self.current_square = *self.squares.get_unchecked(self.current_square);

-				}

-

-				return Some(next_move);

-			}

-

-			if self.current_square != 32 {

-				// safety: self.current_square will never be > 32

-				// squares does not contain such a value

-				unsafe {

-					self.current_square = *self.squares.get_unchecked(self.current_square);

-				}

-			}

-		}

-	}

-

-	fn size_hint(&self) -> (usize, Option<usize>) {

-		(

-			0,

-			Some(

-				(32 - self.current_square)

-					+ 32 * match self.current_direction {

-						MoveDirection::ForwardLeft => 3,

-						MoveDirection::ForwardRight => 2,

-						MoveDirection::BackwardLeft => 1,

-						MoveDirection::BackwardRight => 0,

-					},

-			),

-		)

-	}

-}

+use crate::moves::{Move, MoveDirection};
+use crate::possible_moves::PossibleMoves;
+
+const FORWARD_LEFT_SLIDE_SQUARES: [usize; 33] = [
+	1, 3, 3, 4, 6, 6, 7, 8, 9, 12, 12, 12, 13, 14, 15, 16, 17, 19, 19, 20, 21, 22, 23, 24, 27, 27,
+	27, 28, 29, 30, 32, 32, 32,
+];
+const FORWARD_RIGHT_SLIDE_SQUARES: [usize; 33] = [
+	2, 2, 3, 4, 6, 6, 7, 8, 10, 10, 12, 12, 13, 14, 15, 16, 18, 18, 19, 20, 21, 22, 23, 24, 26, 26,
+	27, 28, 29, 30, 32, 32, 32,
+];
+const BACKWARD_LEFT_SLIDE_SQUARES: [usize; 33] = [
+	1, 3, 3, 4, 5, 7, 7, 8, 9, 11, 11, 13, 13, 14, 15, 16, 17, 19, 19, 20, 21, 22, 23, 24, 25, 27,
+	27, 28, 29, 30, 31, 32, 32,
+];
+const BACKWARD_RIGHT_SLIDE_SQUARES: [usize; 33] = [
+	2, 2, 3, 4, 5, 7, 7, 8, 10, 10, 11, 13, 13, 14, 15, 16, 19, 19, 19, 20, 21, 22, 23, 24, 26, 26,
+	27, 28, 29, 30, 31, 32, 32,
+];
+
+const FORWARD_LEFT_JUMP_SQUARES: [usize; 33] = [
+	1, 6, 6, 6, 6, 6, 7, 8, 9, 12, 12, 12, 13, 14, 15, 16, 17, 20, 20, 20, 21, 22, 23, 28, 28, 28,
+	28, 28, 29, 32, 32, 32, 32,
+];
+const FORWARD_RIGHT_JUMP_SQUARES: [usize; 33] = [
+	2, 2, 3, 6, 6, 6, 7, 12, 12, 12, 12, 12, 13, 14, 15, 18, 18, 18, 19, 20, 21, 22, 23, 26, 26,
+	26, 27, 28, 29, 32, 32, 32, 32,
+];
+const BACKWARD_LEFT_JUMP_SQUARES: [usize; 33] = [
+	4, 4, 4, 4, 5, 8, 8, 8, 9, 14, 14, 14, 14, 14, 15, 16, 17, 20, 20, 20, 21, 22, 23, 24, 25, 28,
+	28, 28, 29, 30, 31, 32, 32,
+];
+const BACKWARD_RIGHT_JUMP_SQUARES: [usize; 33] = [
+	2, 2, 3, 4, 5, 10, 10, 10, 10, 10, 11, 14, 14, 14, 15, 20, 20, 20, 20, 20, 21, 22, 23, 26, 26,
+	26, 27, 28, 29, 30, 31, 32, 32,
+];
+
+static SLIDE_ARRAYS: [[usize; 33]; 4] = [
+	FORWARD_LEFT_SLIDE_SQUARES,
+	FORWARD_RIGHT_SLIDE_SQUARES,
+	BACKWARD_LEFT_SLIDE_SQUARES,
+	BACKWARD_RIGHT_SLIDE_SQUARES,
+];
+
+static JUMP_ARRAYS: [[usize; 33]; 4] = [
+	FORWARD_LEFT_JUMP_SQUARES,
+	FORWARD_RIGHT_JUMP_SQUARES,
+	BACKWARD_LEFT_JUMP_SQUARES,
+	BACKWARD_RIGHT_JUMP_SQUARES,
+];
+
+pub struct PossibleMovesIter {
+	possible_moves: PossibleMoves,
+	current_square: usize,
+	current_direction: MoveDirection,
+	movers: u32,
+	squares: &'static [usize; 33],
+}
+
+impl From<PossibleMoves> for PossibleMovesIter {
+	fn from(possible_moves: PossibleMoves) -> Self {
+		Self {
+			possible_moves,
+			current_square: 0,
+			current_direction: MoveDirection::ForwardLeft,
+			movers: possible_moves.forward_left_bits(),
+			squares: unsafe {
+				if possible_moves.can_jump() {
+					JUMP_ARRAYS.get_unchecked(0)
+				} else {
+					SLIDE_ARRAYS.get_unchecked(0)
+				}
+			},
+		}
+	}
+}
+
+impl Iterator for PossibleMovesIter {
+	type Item = Move;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		loop {
+			if self.current_square == 32 {
+				if self.current_direction != MoveDirection::BackwardRight {
+					self.current_square = 0;
+					// safety: only results in undefined variant if equal to backward right
+					// this has already been checked for
+					self.current_direction =
+						unsafe { std::mem::transmute((self.current_direction as u8) + 1) };
+					self.movers = self
+						.possible_moves
+						.get_direction_bits(self.current_direction);
+
+					// safety: this iterator stops returning values before this
+					// can result in undefined behavior
+					unsafe {
+						self.squares = &*(self.squares as *const [usize; 33]).add(1);
+					}
+				} else {
+					return None;
+				}
+			}
+
+			if (self.movers >> self.current_square) & 1 != 0 {
+				let next_move = Move::new(
+					self.current_square,
+					self.current_direction,
+					self.possible_moves.can_jump(),
+				);
+
+				// safety: self.current_square will never be > 32
+				// squares does not contain such a value
+				unsafe {
+					self.current_square = *self.squares.get_unchecked(self.current_square);
+				}
+
+				return Some(next_move);
+			}
+
+			if self.current_square != 32 {
+				// safety: self.current_square will never be > 32
+				// squares does not contain such a value
+				unsafe {
+					self.current_square = *self.squares.get_unchecked(self.current_square);
+				}
+			}
+		}
+	}
+
+	fn size_hint(&self) -> (usize, Option<usize>) {
+		(
+			0,
+			Some(
+				(32 - self.current_square)
+					+ 32 * match self.current_direction {
+						MoveDirection::ForwardLeft => 3,
+						MoveDirection::ForwardRight => 2,
+						MoveDirection::BackwardLeft => 1,
+						MoveDirection::BackwardRight => 0,
+					},
+			),
+		)
+	}
+}
diff --git a/model/src/possible_moves.rs b/model/src/possible_moves.rs
index 7d4ac29..8c25520 100644
--- a/model/src/possible_moves.rs
+++ b/model/src/possible_moves.rs
@@ -1,326 +1,345 @@
-use crate::moves::{Move, MoveDirection};

-use crate::moves_iter::PossibleMovesIter;

-use crate::{CheckersBitBoard, PieceColor};

-

-#[derive(Copy, Clone, Debug)]

-pub struct PossibleMoves {

-	forward_left_movers: u32,

-	forward_right_movers: u32,

-	backward_left_movers: u32,

-	backward_right_movers: u32,

-	jump: bool,

-}

-

-impl IntoIterator for PossibleMoves {

-	type Item = Move;

-	type IntoIter = PossibleMovesIter;

-

-	fn into_iter(self) -> Self::IntoIter {

-		self.into()

-	}

-}

-

-impl PossibleMoves {

-	const fn slides_dark(board: CheckersBitBoard) -> Self {

-		const FORWARD_LEFT_MASK: u32 = 0b01111001111110111111001111011011;

-		const FORWARD_RIGHT_MASK: u32 = 0b01111101111111011111010111011101;

-		const BACKWARD_LEFT_MASK: u32 = 0b11111011111110111110101110111010;

-		const BACKWARD_RIGHT_MASK: u32 = 0b11111001111110011110110110111100;

-

-		let not_occupied = !board.pieces_bits();

-		let friendly_pieces = board.pieces_bits() & board.color_bits();

-		let friendly_kings = friendly_pieces & board.king_bits();

-

-		let forward_left_movers =

-			not_occupied.rotate_right(7) & friendly_pieces & FORWARD_LEFT_MASK;

-		let forward_right_movers =

-			not_occupied.rotate_right(1) & friendly_pieces & FORWARD_RIGHT_MASK;

-		let backward_left_movers;

-		let backward_right_movers;

-

-		if friendly_kings > 0 {

-			backward_left_movers =

-				not_occupied.rotate_left(1) & friendly_kings & BACKWARD_LEFT_MASK;

-			backward_right_movers =

-				not_occupied.rotate_left(7) & friendly_kings & BACKWARD_RIGHT_MASK;

-		} else {

-			backward_left_movers = 0;

-			backward_right_movers = 0;

-		}

-

-		Self {

-			forward_left_movers,

-			forward_right_movers,

-			backward_left_movers,

-			backward_right_movers,

-			jump: false,

-		}

-	}

-

-	const fn slides_light(board: CheckersBitBoard) -> Self {

-		const FORWARD_LEFT_MASK: u32 = 0b01111001111110111111001111011011;

-		const FORWARD_RIGHT_MASK: u32 = 0b01111101111111011111010111011101;

-		const BACKWARD_LEFT_MASK: u32 = 0b11111011111110111110101110111010;

-		const BACKWARD_RIGHT_MASK: u32 = 0b11111001111110011110110110111100;

-

-		let not_occupied = !board.pieces_bits();

-		let friendly_pieces = board.pieces_bits() & !board.color_bits();

-		let friendly_kings = friendly_pieces & board.king_bits();

-

-		let backward_left_movers =

-			not_occupied.rotate_left(1) & friendly_pieces & BACKWARD_LEFT_MASK;

-		let backward_right_movers =

-			not_occupied.rotate_left(7) & friendly_pieces & BACKWARD_RIGHT_MASK;

-		let forward_left_movers;

-		let forward_right_movers;

-

-		if friendly_kings > 0 {

-			forward_left_movers = not_occupied.rotate_right(7) & friendly_kings & FORWARD_LEFT_MASK;

-			forward_right_movers =

-				not_occupied.rotate_right(1) & friendly_kings & FORWARD_RIGHT_MASK;

-		} else {

-			forward_left_movers = 0;

-			forward_right_movers = 0;

-		}

-

-		Self {

-			forward_left_movers,

-			forward_right_movers,

-			backward_left_movers,

-			backward_right_movers,

-			jump: false,

-		}

-	}

-

-	const fn jumps_dark(board: CheckersBitBoard) -> Self {

-		const FORWARD_LEFT_MASK: u32 = 0b00110000111100111111001111000011;

-		const FORWARD_RIGHT_MASK: u32 = 0b00111100111111001111000011001100;

-		const BACKWARD_LEFT_MASK: u32 = 0b11110011111100111100001100110000;

-		const BACKWARD_RIGHT_MASK: u32 = 0b11111100111100001100110000111100;

-

-		let not_occupied = !board.pieces_bits();

-		let enemy_pieces = board.pieces_bits() & !board.color_bits();

-		let friendly_pieces = board.pieces_bits() & board.color_bits();

-		let friendly_kings = friendly_pieces & board.king_bits();

-

-		let forward_left_movers = not_occupied.rotate_right(14)

-			& enemy_pieces.rotate_right(7)

-			& friendly_pieces

-			& FORWARD_LEFT_MASK;

-		let forward_right_movers = not_occupied.rotate_right(2)

-			& enemy_pieces.rotate_right(1)

-			& friendly_pieces

-			& FORWARD_RIGHT_MASK;

-		let backward_left_movers;

-		let backward_right_movers;

-

-		if friendly_kings > 0 {

-			backward_left_movers = not_occupied.rotate_left(2)

-				& enemy_pieces.rotate_left(1)

-				& friendly_kings & BACKWARD_LEFT_MASK;

-			backward_right_movers = not_occupied.rotate_left(14)

-				& enemy_pieces.rotate_left(7)

-				& friendly_kings & BACKWARD_RIGHT_MASK;

-		} else {

-			backward_left_movers = 0;

-			backward_right_movers = 0;

-		}

-

-		Self {

-			forward_left_movers,

-			forward_right_movers,

-			backward_left_movers,

-			backward_right_movers,

-			jump: true,

-		}

-	}

-

-	const fn jumps_light(board: CheckersBitBoard) -> Self {

-		const FORWARD_LEFT_MASK: u32 = 0b00110000111100111111001111000011;

-		const FORWARD_RIGHT_MASK: u32 = 0b00111100111111001111000011001100;

-		const BACKWARD_LEFT_MASK: u32 = 0b11110011111100111100001100110000;

-		const BACKWARD_RIGHT_MASK: u32 = 0b11111100111100001100110000111100;

-

-		let not_occupied = !board.pieces_bits();

-		let enemy_pieces = board.pieces_bits() & board.color_bits();

-		let friendly_pieces = board.pieces_bits() & !board.color_bits();

-		let friendly_kings = friendly_pieces & board.king_bits();

-

-		let backward_left_movers = not_occupied.rotate_left(2)

-			& enemy_pieces.rotate_left(1)

-			& friendly_pieces

-			& BACKWARD_LEFT_MASK;

-		let backward_right_movers = not_occupied.rotate_left(14)

-			& enemy_pieces.rotate_left(7)

-			& friendly_pieces

-			& BACKWARD_RIGHT_MASK;

-		let forward_left_movers;

-		let forward_right_movers;

-

-		if friendly_kings > 0 {

-			forward_left_movers = not_occupied.rotate_right(14)

-				& enemy_pieces.rotate_right(7)

-				& friendly_kings & FORWARD_LEFT_MASK;

-			forward_right_movers = not_occupied.rotate_right(2)

-				& enemy_pieces.rotate_right(1)

-				& friendly_kings & FORWARD_RIGHT_MASK;

-		} else {

-			forward_left_movers = 0;

-			forward_right_movers = 0;

-		}

-

-		Self {

-			forward_left_movers,

-			forward_right_movers,

-			backward_left_movers,

-			backward_right_movers,

-			jump: true,

-		}

-	}

-

-	pub const fn has_jumps_dark(board: CheckersBitBoard) -> bool {

-		const FORWARD_LEFT_MASK: u32 = 0b00110000111100111111001111000011;

-		const FORWARD_RIGHT_MASK: u32 = 0b00111100111111001111000011001100;

-		const BACKWARD_LEFT_MASK: u32 = 0b11110011111100111100001100110000;

-		const BACKWARD_RIGHT_MASK: u32 = 0b11111100111100001100110000111100;

-

-		let not_occupied = !board.pieces_bits();

-		let enemy_pieces = board.pieces_bits() & !board.color_bits();

-		let friendly_pieces = board.pieces_bits() & board.color_bits();

-

-		let forward_left_spaces =

-			not_occupied.rotate_right(14) & enemy_pieces.rotate_right(7) & FORWARD_LEFT_MASK;

-		let forward_right_spaces =

-			not_occupied.rotate_right(2) & enemy_pieces.rotate_right(1) & FORWARD_RIGHT_MASK;

-

-		let forward_spaces = forward_left_spaces | forward_right_spaces;

-

-		if board.king_bits() > 0 {

-			let backward_left_spaces =

-				not_occupied.rotate_left(2) & enemy_pieces.rotate_left(1) & BACKWARD_LEFT_MASK;

-			let backward_right_spaces =

-				not_occupied.rotate_left(14) & enemy_pieces.rotate_left(7) & BACKWARD_RIGHT_MASK;

-			let backward_spaces = backward_left_spaces | backward_right_spaces;

-

-			let forward_spaces = board.king_bits() & backward_spaces;

-			friendly_pieces & (forward_spaces | backward_spaces) != 0

-		} else {

-			friendly_pieces & forward_spaces != 0

-		}

-	}

-

-	pub const fn has_jumps_light(board: CheckersBitBoard) -> bool {

-		const FORWARD_LEFT_MASK: u32 = 0b00110000111100111111001111000011;

-		const FORWARD_RIGHT_MASK: u32 = 0b00111100111111001111000011001100;

-		const BACKWARD_LEFT_MASK: u32 = 0b11110011111100111100001100110000;

-		const BACKWARD_RIGHT_MASK: u32 = 0b11111100111100001100110000111100;

-

-		let not_occupied = !board.pieces_bits();

-		let enemy_pieces = board.pieces_bits() & board.color_bits();

-		let friendly_pieces = board.pieces_bits() & !board.color_bits();

-

-		let backward_left_spaces =

-			not_occupied.rotate_left(2) & enemy_pieces.rotate_left(1) & BACKWARD_LEFT_MASK;

-		let backward_right_spaces =

-			not_occupied.rotate_left(14) & enemy_pieces.rotate_left(7) & BACKWARD_RIGHT_MASK;

-

-		let backward_spaces = backward_left_spaces | backward_right_spaces;

-

-		if board.king_bits() > 0 {

-			let forward_left_spaces =

-				not_occupied.rotate_right(14) & enemy_pieces.rotate_right(7) & FORWARD_LEFT_MASK;

-			let forward_right_spaces =

-				not_occupied.rotate_right(2) & enemy_pieces.rotate_right(1) & FORWARD_RIGHT_MASK;

-			let forward_spaces = forward_left_spaces | forward_right_spaces;

-

-			let forward_spaces = board.king_bits() & forward_spaces;

-			friendly_pieces & (forward_spaces | backward_spaces) != 0

-		} else {

-			friendly_pieces & backward_spaces != 0

-		}

-	}

-

-	#[inline(always)]

-	pub const fn has_jumps(board: CheckersBitBoard) -> bool {

-		match board.turn() {

-			PieceColor::Light => Self::has_jumps_light(board),

-			PieceColor::Dark => Self::has_jumps_dark(board),

-		}

-	}

-

-	const fn light_moves(board: CheckersBitBoard) -> Self {

-		let jumps = Self::jumps_light(board);

-		if jumps.is_empty() {

-			Self::slides_light(board)

-		} else {

-			jumps

-		}

-	}

-

-	const fn dark_moves(board: CheckersBitBoard) -> Self {

-		let jumps = Self::jumps_dark(board);

-		if jumps.is_empty() {

-			Self::slides_dark(board)

-		} else {

-			jumps

-		}

-	}

-

-	pub const fn moves(board: CheckersBitBoard) -> Self {

-		match board.turn() {

-			PieceColor::Dark => Self::dark_moves(board),

-			PieceColor::Light => Self::light_moves(board),

-		}

-	}

-

-	pub const fn is_empty(self) -> bool {

-		(self.backward_left_movers

-			| self.forward_left_movers

-			| self.forward_right_movers

-			| self.backward_right_movers)

-			== 0

-	}

-

-	pub const fn can_jump(self) -> bool {

-		self.jump

-	}

-

-	pub const fn forward_left_bits(self) -> u32 {

-		self.forward_left_movers

-	}

-

-	pub const fn get_direction_bits(self, direction: MoveDirection) -> u32 {

-		match direction {

-			MoveDirection::ForwardLeft => self.forward_left_movers,

-			MoveDirection::ForwardRight => self.forward_right_movers,

-			MoveDirection::BackwardLeft => self.backward_left_movers,

-			MoveDirection::BackwardRight => self.backward_right_movers,

-		}

-	}

-}

-

-#[cfg(test)]

-mod tests {

-	use super::*;

-

-	#[test]

-	fn same() {

-		let start = CheckersBitBoard::new(

-			0b11100111100111100111110111111011,

-			0b00001100001111001111001111000011,

-			0,

-			PieceColor::Dark,

-		);

-		let flip = CheckersBitBoard::new(

-			0b11100111100111100111110111111011,

-			0b11110011110000110000110000111100,

-			0,

-			PieceColor::Light,

-		);

-

-		assert_eq!(

-			PossibleMoves::has_jumps(start),

-			PossibleMoves::has_jumps(flip)

-		)

-	}

-}

+use crate::moves::{Move, MoveDirection};
+use crate::moves_iter::PossibleMovesIter;
+use crate::{CheckersBitBoard, PieceColor};
+
+#[derive(Copy, Clone, Debug)]
+pub struct PossibleMoves {
+	forward_left_movers: u32,
+	forward_right_movers: u32,
+	backward_left_movers: u32,
+	backward_right_movers: u32,
+	jump: bool,
+}
+
+impl IntoIterator for PossibleMoves {
+	type Item = Move;
+	type IntoIter = PossibleMovesIter;
+
+	fn into_iter(self) -> Self::IntoIter {
+		self.into()
+	}
+}
+
+impl PossibleMoves {
+	const fn slides_dark(board: CheckersBitBoard) -> Self {
+		const FORWARD_LEFT_MASK: u32 = 0b01111001111110111111001111011011;
+		const FORWARD_RIGHT_MASK: u32 = 0b01111101111111011111010111011101;
+		const BACKWARD_LEFT_MASK: u32 = 0b11111011111110111110101110111010;
+		const BACKWARD_RIGHT_MASK: u32 = 0b11111001111110011110110110111100;
+
+		let not_occupied = !board.pieces_bits();
+		let friendly_pieces = board.pieces_bits() & board.color_bits();
+		let friendly_kings = friendly_pieces & board.king_bits();
+
+		let forward_left_movers =
+			not_occupied.rotate_right(7) & friendly_pieces & FORWARD_LEFT_MASK;
+		let forward_right_movers =
+			not_occupied.rotate_right(1) & friendly_pieces & FORWARD_RIGHT_MASK;
+		let backward_left_movers;
+		let backward_right_movers;
+
+		if friendly_kings > 0 {
+			backward_left_movers =
+				not_occupied.rotate_left(1) & friendly_kings & BACKWARD_LEFT_MASK;
+			backward_right_movers =
+				not_occupied.rotate_left(7) & friendly_kings & BACKWARD_RIGHT_MASK;
+		} else {
+			backward_left_movers = 0;
+			backward_right_movers = 0;
+		}
+
+		Self {
+			forward_left_movers,
+			forward_right_movers,
+			backward_left_movers,
+			backward_right_movers,
+			jump: false,
+		}
+	}
+
+	const fn slides_light(board: CheckersBitBoard) -> Self {
+		const FORWARD_LEFT_MASK: u32 = 0b01111001111110111111001111011011;
+		const FORWARD_RIGHT_MASK: u32 = 0b01111101111111011111010111011101;
+		const BACKWARD_LEFT_MASK: u32 = 0b11111011111110111110101110111010;
+		const BACKWARD_RIGHT_MASK: u32 = 0b11111001111110011110110110111100;
+
+		let not_occupied = !board.pieces_bits();
+		let friendly_pieces = board.pieces_bits() & !board.color_bits();
+		let friendly_kings = friendly_pieces & board.king_bits();
+
+		let backward_left_movers =
+			not_occupied.rotate_left(1) & friendly_pieces & BACKWARD_LEFT_MASK;
+		let backward_right_movers =
+			not_occupied.rotate_left(7) & friendly_pieces & BACKWARD_RIGHT_MASK;
+		let forward_left_movers;
+		let forward_right_movers;
+
+		if friendly_kings > 0 {
+			forward_left_movers = not_occupied.rotate_right(7) & friendly_kings & FORWARD_LEFT_MASK;
+			forward_right_movers =
+				not_occupied.rotate_right(1) & friendly_kings & FORWARD_RIGHT_MASK;
+		} else {
+			forward_left_movers = 0;
+			forward_right_movers = 0;
+		}
+
+		Self {
+			forward_left_movers,
+			forward_right_movers,
+			backward_left_movers,
+			backward_right_movers,
+			jump: false,
+		}
+	}
+
+	const fn jumps_dark(board: CheckersBitBoard) -> Self {
+		const FORWARD_LEFT_MASK: u32 = 0b00110000111100111111001111000011;
+		const FORWARD_RIGHT_MASK: u32 = 0b00111100111111001111000011001100;
+		const BACKWARD_LEFT_MASK: u32 = 0b11110011111100111100001100110000;
+		const BACKWARD_RIGHT_MASK: u32 = 0b11111100111100001100110000111100;
+
+		let not_occupied = !board.pieces_bits();
+		let enemy_pieces = board.pieces_bits() & !board.color_bits();
+		let friendly_pieces = board.pieces_bits() & board.color_bits();
+		let friendly_kings = friendly_pieces & board.king_bits();
+
+		let forward_left_movers = not_occupied.rotate_right(14)
+			& enemy_pieces.rotate_right(7)
+			& friendly_pieces
+			& FORWARD_LEFT_MASK;
+		let forward_right_movers = not_occupied.rotate_right(2)
+			& enemy_pieces.rotate_right(1)
+			& friendly_pieces
+			& FORWARD_RIGHT_MASK;
+		let backward_left_movers;
+		let backward_right_movers;
+
+		if friendly_kings > 0 {
+			backward_left_movers = not_occupied.rotate_left(2)
+				& enemy_pieces.rotate_left(1)
+				& friendly_kings & BACKWARD_LEFT_MASK;
+			backward_right_movers = not_occupied.rotate_left(14)
+				& enemy_pieces.rotate_left(7)
+				& friendly_kings & BACKWARD_RIGHT_MASK;
+		} else {
+			backward_left_movers = 0;
+			backward_right_movers = 0;
+		}
+
+		Self {
+			forward_left_movers,
+			forward_right_movers,
+			backward_left_movers,
+			backward_right_movers,
+			jump: true,
+		}
+	}
+
+	const fn jumps_light(board: CheckersBitBoard) -> Self {
+		const FORWARD_LEFT_MASK: u32 = 0b00110000111100111111001111000011;
+		const FORWARD_RIGHT_MASK: u32 = 0b00111100111111001111000011001100;
+		const BACKWARD_LEFT_MASK: u32 = 0b11110011111100111100001100110000;
+		const BACKWARD_RIGHT_MASK: u32 = 0b11111100111100001100110000111100;
+
+		let not_occupied = !board.pieces_bits();
+		let enemy_pieces = board.pieces_bits() & board.color_bits();
+		let friendly_pieces = board.pieces_bits() & !board.color_bits();
+		let friendly_kings = friendly_pieces & board.king_bits();
+
+		let backward_left_movers = not_occupied.rotate_left(2)
+			& enemy_pieces.rotate_left(1)
+			& friendly_pieces
+			& BACKWARD_LEFT_MASK;
+		let backward_right_movers = not_occupied.rotate_left(14)
+			& enemy_pieces.rotate_left(7)
+			& friendly_pieces
+			& BACKWARD_RIGHT_MASK;
+		let forward_left_movers;
+		let forward_right_movers;
+
+		if friendly_kings > 0 {
+			forward_left_movers = not_occupied.rotate_right(14)
+				& enemy_pieces.rotate_right(7)
+				& friendly_kings & FORWARD_LEFT_MASK;
+			forward_right_movers = not_occupied.rotate_right(2)
+				& enemy_pieces.rotate_right(1)
+				& friendly_kings & FORWARD_RIGHT_MASK;
+		} else {
+			forward_left_movers = 0;
+			forward_right_movers = 0;
+		}
+
+		Self {
+			forward_left_movers,
+			forward_right_movers,
+			backward_left_movers,
+			backward_right_movers,
+			jump: true,
+		}
+	}
+
+	// TODO make this private
+	pub const fn has_jumps_dark(board: CheckersBitBoard) -> bool {
+		const FORWARD_LEFT_MASK: u32 = 0b00110000111100111111001111000011;
+		const FORWARD_RIGHT_MASK: u32 = 0b00111100111111001111000011001100;
+		const BACKWARD_LEFT_MASK: u32 = 0b11110011111100111100001100110000;
+		const BACKWARD_RIGHT_MASK: u32 = 0b11111100111100001100110000111100;
+
+		let not_occupied = !board.pieces_bits();
+		let enemy_pieces = board.pieces_bits() & !board.color_bits();
+		let friendly_pieces = board.pieces_bits() & board.color_bits();
+
+		let forward_left_spaces =
+			not_occupied.rotate_right(14) & enemy_pieces.rotate_right(7) & FORWARD_LEFT_MASK;
+		let forward_right_spaces =
+			not_occupied.rotate_right(2) & enemy_pieces.rotate_right(1) & FORWARD_RIGHT_MASK;
+
+		let forward_spaces = forward_left_spaces | forward_right_spaces;
+
+		if board.king_bits() > 0 {
+			let backward_left_spaces =
+				not_occupied.rotate_left(2) & enemy_pieces.rotate_left(1) & BACKWARD_LEFT_MASK;
+			let backward_right_spaces =
+				not_occupied.rotate_left(14) & enemy_pieces.rotate_left(7) & BACKWARD_RIGHT_MASK;
+			let backward_spaces = backward_left_spaces | backward_right_spaces;
+
+			let forward_spaces = board.king_bits() & backward_spaces;
+			friendly_pieces & (forward_spaces | backward_spaces) != 0
+		} else {
+			friendly_pieces & forward_spaces != 0
+		}
+	}
+
+	// TODO make this private
+	pub const fn has_jumps_light(board: CheckersBitBoard) -> bool {
+		const FORWARD_LEFT_MASK: u32 = 0b00110000111100111111001111000011;
+		const FORWARD_RIGHT_MASK: u32 = 0b00111100111111001111000011001100;
+		const BACKWARD_LEFT_MASK: u32 = 0b11110011111100111100001100110000;
+		const BACKWARD_RIGHT_MASK: u32 = 0b11111100111100001100110000111100;
+
+		let not_occupied = !board.pieces_bits();
+		let enemy_pieces = board.pieces_bits() & board.color_bits();
+		let friendly_pieces = board.pieces_bits() & !board.color_bits();
+
+		let backward_left_spaces =
+			not_occupied.rotate_left(2) & enemy_pieces.rotate_left(1) & BACKWARD_LEFT_MASK;
+		let backward_right_spaces =
+			not_occupied.rotate_left(14) & enemy_pieces.rotate_left(7) & BACKWARD_RIGHT_MASK;
+
+		let backward_spaces = backward_left_spaces | backward_right_spaces;
+
+		if board.king_bits() > 0 {
+			let forward_left_spaces =
+				not_occupied.rotate_right(14) & enemy_pieces.rotate_right(7) & FORWARD_LEFT_MASK;
+			let forward_right_spaces =
+				not_occupied.rotate_right(2) & enemy_pieces.rotate_right(1) & FORWARD_RIGHT_MASK;
+			let forward_spaces = forward_left_spaces | forward_right_spaces;
+
+			let forward_spaces = board.king_bits() & forward_spaces;
+			friendly_pieces & (forward_spaces | backward_spaces) != 0
+		} else {
+			friendly_pieces & backward_spaces != 0
+		}
+	}
+
+	#[inline(always)]
+	// TODO optimize
+	pub const fn has_jumps(board: CheckersBitBoard) -> bool {
+		match board.turn() {
+			PieceColor::Light => Self::has_jumps_light(board),
+			PieceColor::Dark => Self::has_jumps_dark(board),
+		}
+	}
+
+	const fn light_moves(board: CheckersBitBoard) -> Self {
+		let jumps = Self::jumps_light(board);
+		if jumps.is_empty() {
+			Self::slides_light(board)
+		} else {
+			jumps
+		}
+	}
+
+	const fn dark_moves(board: CheckersBitBoard) -> Self {
+		let jumps = Self::jumps_dark(board);
+		if jumps.is_empty() {
+			Self::slides_dark(board)
+		} else {
+			jumps
+		}
+	}
+
+	pub const fn moves(board: CheckersBitBoard) -> Self {
+		match board.turn() {
+			PieceColor::Dark => Self::dark_moves(board),
+			PieceColor::Light => Self::light_moves(board),
+		}
+	}
+
+	/// Returns true if no moves are possible
+	pub const fn is_empty(self) -> bool {
+		(self.backward_left_movers
+			| self.forward_left_movers
+			| self.forward_right_movers
+			| self.backward_right_movers)
+			== 0
+	}
+
+	/// Returns true if the piece can jump
+	pub const fn can_jump(self) -> bool {
+		self.jump
+	}
+
+	/// Returns the pieces who can move forward left,
+	/// with undefined behavior for bits where a forward left move is impossible
+	///
+	/// # Safety
+	///
+	/// This function is inherently unsafe because some bits are undefined
+	// TODO make this unsafe
+	pub const fn forward_left_bits(self) -> u32 {
+		self.forward_left_movers
+	}
+
+	/// Gets the bits for a certain direction,
+	/// with undefined behavior for bits where the given move is impossible
+	///
+	/// # Safety
+	///
+	/// This function is inherently unsafe because some bits are undefined
+	// TODO make this unsafe
+	pub const fn get_direction_bits(self, direction: MoveDirection) -> u32 {
+		match direction {
+			MoveDirection::ForwardLeft => self.forward_left_movers,
+			MoveDirection::ForwardRight => self.forward_right_movers,
+			MoveDirection::BackwardLeft => self.backward_left_movers,
+			MoveDirection::BackwardRight => self.backward_right_movers,
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn same() {
+		let start = CheckersBitBoard::new(
+			0b11100111100111100111110111111011,
+			0b00001100001111001111001111000011,
+			0,
+			PieceColor::Dark,
+		);
+		let flip = CheckersBitBoard::new(
+			0b11100111100111100111110111111011,
+			0b11110011110000110000110000111100,
+			0,
+			PieceColor::Light,
+		);
+
+		assert_eq!(
+			PossibleMoves::has_jumps(start),
+			PossibleMoves::has_jumps(flip)
+		)
+	}
+}