Remove position from Piece struct

rs/src/board.rs

@@ -45,6 +45,15 @@ impl Position {
             self.file.delta(delta_file)?,
         ))
     }
+    fn deltas_to_valid_positions(
+        &self,
+        deltas: &Vec<(i8, i8)>,
+    ) -> Vec<Position> {
+        deltas
+            .iter()
+            .filter_map(|&delta_rank_file| self.delta(delta_rank_file).ok())
+            .collect()
+    }
 }
 
 #[derive(PartialEq, Clone, Copy)]
@@ -142,15 +151,19 @@ pub enum PieceType {
 }
 
 impl PieceType {
-    fn initial_setup(&self) -> Vec<Piece> {
+    fn initial_setup(&self) -> Vec<(Piece, Position)> {
         match &self {
             PieceType::Pawn => [Color::Black, Color::White]
                 .iter()
                 .flat_map(|color| {
-                    File::ALL_VALUES.iter().map(|&file| Piece {
+                    File::ALL_VALUES.iter().map(|&file| {
-                        piece_type: self.clone(),
+                        (
-                        position: Position::new(color.get_pawn_rank(), file),
+                            Piece {
-                        color: color.clone(),
+                                piece_type: self.clone(),
+                                color: color.clone(),
+                            },
+                            Position::new(color.get_pawn_rank(), file),
+                        )
                     })
                 })
                 .collect(),
@@ -159,43 +172,26 @@ impl PieceType {
 }
 
 pub struct Piece {
-    position: Position,
     color: Color,
     piece_type: PieceType,
 }
 
-trait Movement {
-    fn get_moves(&self) -> Vec<Position>;
-    fn get_captures(&self) -> Vec<Position>;
-}
-
 impl Piece {
-    fn get_moves(&self) -> Vec<Position> {
+    fn get_moves(&self, position: &Position) -> Vec<Position> {
         let deltas = match self.piece_type {
-            PieceType::Pawn => self._pawn_get_move_deltas(),
+            PieceType::Pawn => self._pawn_get_move_deltas(position),
         };
-        self.deltas_to_valid_positions(&deltas)
+        position.deltas_to_valid_positions(&deltas)
     }
-    fn get_captures(&self) -> Vec<Position> {
+    fn get_captures(&self, position: &Position) -> Vec<Position> {
         let deltas = match self.piece_type {
             PieceType::Pawn => self._pawn_get_capture_deltas(),
         };
-        self.deltas_to_valid_positions(&deltas)
+        position.deltas_to_valid_positions(&deltas)
     }
-    fn deltas_to_valid_positions(
+    fn _pawn_get_move_deltas(&self, position: &Position) -> Vec<(i8, i8)> {
-        &self,
-        deltas: &Vec<(i8, i8)>,
-    ) -> Vec<Position> {
-        deltas
-            .iter()
-            .filter_map(|&delta_rank_file| {
-                self.position.delta(delta_rank_file).ok()
-            })
-            .collect()
-    }
-    fn _pawn_get_move_deltas(&self) -> Vec<(i8, i8)> {
         let direction = self.color.get_direction();
-        if self.position.rank == self.color.get_pawn_rank() {
+        if position.rank == self.color.get_pawn_rank() {
             vec![(1 * direction, 0), (2 * direction, 0)]
         } else {
             vec![(1 * direction, 0)]
@@ -216,18 +212,17 @@ impl Board {
         &self.state[position.rank.get_index() as usize]
             [position.file.get_index() as usize]
     }
-    fn set_at(&mut self, position: &Position, mut piece: Piece) {
+    fn set_at(&mut self, position: &Position, piece_or_empty: Option<Piece>) {
-        piece.position = position.clone();
         self.state[position.rank.get_index() as usize]
-            [position.file.get_index() as usize] = Some(piece);
+            [position.file.get_index() as usize] = piece_or_empty;
     }
     pub fn new() -> Board {
         let mut board = Board {
             state: Default::default(),
         };
         for piece_type in &[PieceType::Pawn] {
-            for piece in piece_type.initial_setup() {
+            for (piece, position) in piece_type.initial_setup() {
-                board.set_at(&piece.position.clone(), piece);
+                board.set_at(&position, Some(piece));
             }
         }
         board