diff options
Diffstat (limited to 'model')
| -rw-r--r-- | model/src/lib.rs | 1 | ||||
| -rw-r--r-- | model/src/moves_iter.rs | 144 | ||||
| -rw-r--r-- | model/src/possible_moves.rs | 295 |
3 files changed, 293 insertions, 147 deletions
diff --git a/model/src/lib.rs b/model/src/lib.rs index 7b21be5..8c8efb6 100644 --- a/model/src/lib.rs +++ b/model/src/lib.rs @@ -1,7 +1,6 @@ mod board; mod color; mod moves; -mod moves_iter; mod possible_moves; pub use board::CheckersBitBoard; diff --git a/model/src/moves_iter.rs b/model/src/moves_iter.rs deleted file mode 100644 index ffa59b6..0000000 --- a/model/src/moves_iter.rs +++ /dev/null @@ -1,144 +0,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 089ccf6..fc1f595 100644 --- a/model/src/possible_moves.rs +++ b/model/src/possible_moves.rs @@ -1,6 +1,10 @@ use crate::moves::{Move, MoveDirection}; -use crate::moves_iter::PossibleMovesIter; use crate::{CheckersBitBoard, PieceColor}; +use std::alloc::{alloc, dealloc, handle_alloc_error, Layout}; +use std::mem::MaybeUninit; +use std::ptr::NonNull; + +const POSSIBLE_MOVES_ITER_SIZE: usize = 98; #[derive(Copy, Clone, Debug)] pub struct PossibleMoves { @@ -10,12 +14,299 @@ pub struct PossibleMoves { backward_right_movers: u32, } +pub struct PossibleMovesIter { + moves: NonNull<[MaybeUninit<Move>; POSSIBLE_MOVES_ITER_SIZE]>, + index: usize, + length: usize, +} + +impl PossibleMovesIter { + fn add_slide_forward_left<const SQUARE: usize>(&mut self, possible_moves: PossibleMoves) { + if (possible_moves.forward_left_movers >> SQUARE) & 1 != 0 { + let ptr = unsafe { self.moves.as_mut().get_unchecked_mut(self.length) }; + *ptr = MaybeUninit::new(Move::new(SQUARE, MoveDirection::ForwardLeft, false)); + self.length += 1; + } + } + + fn add_slide_forward_right<const SQUARE: usize>(&mut self, possible_moves: PossibleMoves) { + if (possible_moves.forward_right_movers >> SQUARE) & 1 != 0 { + let ptr = unsafe { self.moves.as_mut().get_unchecked_mut(self.length) }; + *ptr = MaybeUninit::new(Move::new(SQUARE, MoveDirection::ForwardRight, false)); + self.length += 1; + } + } + + fn add_slide_backward_left<const SQUARE: usize>(&mut self, possible_moves: PossibleMoves) { + if (possible_moves.backward_left_movers >> SQUARE) & 1 != 0 { + let ptr = unsafe { self.moves.as_mut().get_unchecked_mut(self.length) }; + *ptr = MaybeUninit::new(Move::new(SQUARE, MoveDirection::BackwardLeft, false)); + self.length += 1; + } + } + + fn add_slide_backward_right<const SQUARE: usize>(&mut self, possible_moves: PossibleMoves) { + if (possible_moves.backward_right_movers >> SQUARE) & 1 != 0 { + let ptr = unsafe { self.moves.as_mut().get_unchecked_mut(self.length) }; + *ptr = MaybeUninit::new(Move::new(SQUARE, MoveDirection::BackwardRight, false)); + self.length += 1; + } + } + + fn add_jump_forward_left<const SQUARE: usize>(&mut self, possible_moves: PossibleMoves) { + if (possible_moves.forward_left_movers >> SQUARE) & 1 != 0 { + let ptr = unsafe { self.moves.as_mut().get_unchecked_mut(self.length) }; + *ptr = MaybeUninit::new(Move::new(SQUARE, MoveDirection::ForwardLeft, true)); + self.length += 1; + } + } + + fn add_jump_forward_right<const SQUARE: usize>(&mut self, possible_moves: PossibleMoves) { + if (possible_moves.forward_right_movers >> SQUARE) & 1 != 0 { + let ptr = unsafe { self.moves.as_mut().get_unchecked_mut(self.length) }; + *ptr = MaybeUninit::new(Move::new(SQUARE, MoveDirection::ForwardRight, true)); + self.length += 1; + } + } + + fn add_jump_backward_left<const SQUARE: usize>(&mut self, possible_moves: PossibleMoves) { + if (possible_moves.backward_left_movers >> SQUARE) & 1 != 0 { + let ptr = unsafe { self.moves.as_mut().get_unchecked_mut(self.length) }; + *ptr = MaybeUninit::new(Move::new(SQUARE, MoveDirection::BackwardLeft, true)); + self.length += 1; + } + } + + fn add_jump_backward_right<const SQUARE: usize>(&mut self, possible_moves: PossibleMoves) { + if (possible_moves.backward_right_movers >> SQUARE) & 1 != 0 { + let ptr = unsafe { self.moves.as_mut().get_unchecked_mut(self.length) }; + *ptr = MaybeUninit::new(Move::new(SQUARE, MoveDirection::BackwardRight, true)); + self.length += 1; + } + } +} + +impl Iterator for PossibleMovesIter { + type Item = Move; + + fn next(&mut self) -> Option<Self::Item> { + if self.length != self.index { + let next_move = unsafe { self.moves.as_ref().get_unchecked(self.index).assume_init() }; + self.index += 1; + Some(next_move) + } else { + None + } + } +} + +impl Drop for PossibleMovesIter { + fn drop(&mut self) { + let layout = Layout::array::<MaybeUninit<Move>>(POSSIBLE_MOVES_ITER_SIZE).unwrap(); + unsafe { dealloc(self.moves.as_ptr() as *mut u8, layout) } + } +} + impl IntoIterator for PossibleMoves { type Item = Move; type IntoIter = PossibleMovesIter; fn into_iter(self) -> Self::IntoIter { - self.into() + let layout = Layout::array::<MaybeUninit<Move>>(POSSIBLE_MOVES_ITER_SIZE).unwrap(); + let allocated_mem = unsafe { alloc(layout) }; + let ptr = + match NonNull::new(allocated_mem as *mut [MaybeUninit<Move>; POSSIBLE_MOVES_ITER_SIZE]) + { + Some(p) => p, + None => handle_alloc_error(layout), + }; + let mut iter = PossibleMovesIter { + moves: ptr, + index: 0, + length: 0, + }; + + if self.can_jump() { + iter.add_jump_forward_left::<0>(self); + iter.add_jump_forward_left::<1>(self); + iter.add_jump_forward_left::<6>(self); + iter.add_jump_forward_left::<7>(self); + iter.add_jump_forward_left::<8>(self); + iter.add_jump_forward_left::<9>(self); + iter.add_jump_forward_left::<12>(self); + iter.add_jump_forward_left::<13>(self); + iter.add_jump_forward_left::<14>(self); + iter.add_jump_forward_left::<15>(self); + iter.add_jump_forward_left::<16>(self); + iter.add_jump_forward_left::<17>(self); + iter.add_jump_forward_left::<20>(self); + iter.add_jump_forward_left::<21>(self); + iter.add_jump_forward_left::<22>(self); + iter.add_jump_forward_left::<23>(self); + iter.add_jump_forward_left::<28>(self); + iter.add_jump_forward_left::<29>(self); + + iter.add_jump_forward_right::<2>(self); + iter.add_jump_forward_right::<3>(self); + iter.add_jump_forward_right::<6>(self); + iter.add_jump_forward_right::<7>(self); + iter.add_jump_forward_right::<12>(self); + iter.add_jump_forward_right::<13>(self); + iter.add_jump_forward_right::<14>(self); + iter.add_jump_forward_right::<15>(self); + iter.add_jump_forward_right::<18>(self); + iter.add_jump_forward_right::<19>(self); + iter.add_jump_forward_right::<20>(self); + iter.add_jump_forward_right::<21>(self); + iter.add_jump_forward_right::<22>(self); + iter.add_jump_forward_right::<23>(self); + iter.add_jump_forward_right::<26>(self); + iter.add_jump_forward_right::<27>(self); + iter.add_jump_forward_right::<28>(self); + iter.add_jump_forward_right::<29>(self); + + iter.add_jump_backward_left::<4>(self); + iter.add_jump_backward_left::<5>(self); + iter.add_jump_backward_left::<8>(self); + iter.add_jump_backward_left::<9>(self); + iter.add_jump_backward_left::<14>(self); + iter.add_jump_backward_left::<15>(self); + iter.add_jump_backward_left::<16>(self); + iter.add_jump_backward_left::<17>(self); + iter.add_jump_backward_left::<20>(self); + iter.add_jump_backward_left::<21>(self); + iter.add_jump_backward_left::<22>(self); + iter.add_jump_backward_left::<23>(self); + iter.add_jump_backward_left::<24>(self); + iter.add_jump_backward_left::<25>(self); + iter.add_jump_backward_left::<28>(self); + iter.add_jump_backward_left::<29>(self); + iter.add_jump_backward_left::<30>(self); + iter.add_jump_backward_left::<31>(self); + + iter.add_jump_backward_right::<2>(self); + iter.add_jump_backward_right::<3>(self); + iter.add_jump_backward_right::<4>(self); + iter.add_jump_backward_right::<5>(self); + iter.add_jump_backward_right::<10>(self); + iter.add_jump_backward_right::<11>(self); + iter.add_jump_backward_right::<14>(self); + iter.add_jump_backward_right::<15>(self); + iter.add_jump_backward_right::<20>(self); + iter.add_jump_backward_right::<21>(self); + iter.add_jump_backward_right::<22>(self); + iter.add_jump_backward_right::<23>(self); + iter.add_jump_backward_right::<26>(self); + iter.add_jump_backward_right::<27>(self); + iter.add_jump_backward_right::<28>(self); + iter.add_jump_backward_right::<29>(self); + iter.add_jump_backward_right::<30>(self); + iter.add_jump_backward_right::<31>(self); + } else { + iter.add_slide_forward_left::<0>(self); + iter.add_slide_forward_left::<1>(self); + iter.add_slide_forward_left::<3>(self); + iter.add_slide_forward_left::<4>(self); + iter.add_slide_forward_left::<6>(self); + iter.add_slide_forward_left::<7>(self); + iter.add_slide_forward_left::<8>(self); + iter.add_slide_forward_left::<9>(self); + iter.add_slide_forward_left::<12>(self); + iter.add_slide_forward_left::<13>(self); + iter.add_slide_forward_left::<14>(self); + iter.add_slide_forward_left::<15>(self); + iter.add_slide_forward_left::<16>(self); + iter.add_slide_forward_left::<17>(self); + iter.add_slide_forward_left::<19>(self); + iter.add_slide_forward_left::<20>(self); + iter.add_slide_forward_left::<21>(self); + iter.add_slide_forward_left::<22>(self); + iter.add_slide_forward_left::<23>(self); + iter.add_slide_forward_left::<24>(self); + iter.add_slide_forward_left::<27>(self); + iter.add_slide_forward_left::<28>(self); + iter.add_slide_forward_left::<29>(self); + iter.add_slide_forward_left::<30>(self); + + iter.add_slide_forward_right::<0>(self); + iter.add_slide_forward_right::<2>(self); + iter.add_slide_forward_right::<3>(self); + iter.add_slide_forward_right::<4>(self); + iter.add_slide_forward_right::<6>(self); + iter.add_slide_forward_right::<7>(self); + iter.add_slide_forward_right::<8>(self); + iter.add_slide_forward_right::<10>(self); + iter.add_slide_forward_right::<12>(self); + iter.add_slide_forward_right::<13>(self); + iter.add_slide_forward_right::<14>(self); + iter.add_slide_forward_right::<15>(self); + iter.add_slide_forward_right::<16>(self); + iter.add_slide_forward_right::<18>(self); + iter.add_slide_forward_right::<19>(self); + iter.add_slide_forward_right::<20>(self); + iter.add_slide_forward_right::<21>(self); + iter.add_slide_forward_right::<22>(self); + iter.add_slide_forward_right::<23>(self); + iter.add_slide_forward_right::<24>(self); + iter.add_slide_forward_right::<26>(self); + iter.add_slide_forward_right::<27>(self); + iter.add_slide_forward_right::<28>(self); + iter.add_slide_forward_right::<29>(self); + iter.add_slide_forward_right::<30>(self); + + iter.add_slide_backward_left::<1>(self); + iter.add_slide_backward_left::<3>(self); + iter.add_slide_backward_left::<4>(self); + iter.add_slide_backward_left::<5>(self); + iter.add_slide_backward_left::<7>(self); + iter.add_slide_backward_left::<8>(self); + iter.add_slide_backward_left::<9>(self); + iter.add_slide_backward_left::<11>(self); + iter.add_slide_backward_left::<13>(self); + iter.add_slide_backward_left::<14>(self); + iter.add_slide_backward_left::<15>(self); + iter.add_slide_backward_left::<16>(self); + iter.add_slide_backward_left::<17>(self); + iter.add_slide_backward_left::<19>(self); + iter.add_slide_backward_left::<20>(self); + iter.add_slide_backward_left::<21>(self); + iter.add_slide_backward_left::<22>(self); + iter.add_slide_backward_left::<23>(self); + iter.add_slide_backward_left::<24>(self); + iter.add_slide_backward_left::<25>(self); + iter.add_slide_backward_left::<27>(self); + iter.add_slide_backward_left::<28>(self); + iter.add_slide_backward_left::<29>(self); + iter.add_slide_backward_left::<30>(self); + iter.add_slide_backward_left::<31>(self); + + iter.add_slide_backward_right::<2>(self); + iter.add_slide_backward_right::<3>(self); + iter.add_slide_backward_right::<4>(self); + iter.add_slide_backward_right::<5>(self); + iter.add_slide_backward_right::<7>(self); + iter.add_slide_backward_right::<8>(self); + iter.add_slide_backward_right::<10>(self); + iter.add_slide_backward_right::<11>(self); + iter.add_slide_backward_right::<13>(self); + iter.add_slide_backward_right::<14>(self); + iter.add_slide_backward_right::<15>(self); + iter.add_slide_backward_right::<16>(self); + iter.add_slide_backward_right::<19>(self); + iter.add_slide_backward_right::<20>(self); + iter.add_slide_backward_right::<21>(self); + iter.add_slide_backward_right::<22>(self); + iter.add_slide_backward_right::<23>(self); + iter.add_slide_backward_right::<24>(self); + iter.add_slide_backward_right::<26>(self); + iter.add_slide_backward_right::<27>(self); + iter.add_slide_backward_right::<28>(self); + iter.add_slide_backward_right::<29>(self); + iter.add_slide_backward_right::<30>(self); + iter.add_slide_backward_right::<31>(self); + } + + iter } } |