fix: remove dead functions and unused imports

Author: lsoulet

topics/tic-tac-toe/src/ai.rs

@@ -1,4 +1,4 @@
-use crate::board::{Board, Player, Cell};
+use crate::board::{Cell, Player};
 use crate::game::Game;
 
 /// AI player that uses the Minimax algorithm to play optimally
@@ -24,11 +24,11 @@ impl AI {
 
         for &position in &available_moves {
             let mut game_copy = self.clone_game(game);
-            
+
             game_copy.make_move(position);
-            
+
             let score = self.minimax(&game_copy, 0, false);
-            
+
             if score > best_score {
                 best_score = score;
                 best_move = Some(position);
@@ -45,9 +45,9 @@ impl AI {
         // Check terminal states (game over)
         if let Some(winner) = game.check_winner() {
             return if winner == self.player {
-                10 - depth as i32  // AI wins: prefer winning sooner (higher score for fewer moves)
+                10 - depth as i32 // AI wins: prefer winning sooner (higher score for fewer moves)
             } else {
-                depth as i32 - 10  // AI loses: prefer losing later (less negative score)
+                depth as i32 - 10 // AI loses: prefer losing later (less negative score)
             };
         }
 
@@ -56,32 +56,32 @@ impl AI {
         }
 
         let available_moves = game.get_available_moves();
-        
+
         if is_maximizing {
             // AI's turn - maximize the score
             let mut max_score = i32::MIN;
-            
+
             for &position in &available_moves {
                 let mut game_copy = self.clone_game(game);
                 game_copy.make_move(position);
-                
+
                 let score = self.minimax(&game_copy, depth + 1, false);
                 max_score = max_score.max(score);
             }
-            
+
             max_score
         } else {
             // Opponent's turn - minimize the score (from AI's perspective)
             let mut min_score = i32::MAX;
-            
+
             for &position in &available_moves {
                 let mut game_copy = self.clone_game(game);
                 game_copy.make_move(position);
-                
+
                 let score = self.minimax(&game_copy, depth + 1, true);
                 min_score = min_score.min(score);
             }
-            
+
             min_score
         }
     }
@@ -91,17 +91,16 @@ impl AI {
     fn clone_game(&self, game: &Game) -> Game {
         let mut new_game = Game::new();
 
-        let board = game.get_board();
+                let board = game.get_board();
 
-        let mut moves = Vec::new();
+                let mut moves = Vec::new();
         for position in 1..=9 {
             if let Some(Cell::Occupied(player)) = board.get_cell(position) {
                 moves.push((position, player));
             }
         }
 
-
-        let mut x_moves = Vec::new();
+                let mut x_moves = Vec::new();
         let mut o_moves = Vec::new();
 
         for (pos, player) in moves {
@@ -111,7 +110,7 @@ impl AI {
             }
         }
 
-        let mut move_sequence = Vec::new();
+                let mut move_sequence = Vec::new();
         let max_len = x_moves.len().max(o_moves.len());
 
         for i in 0..max_len {
@@ -123,7 +122,7 @@ impl AI {
             }
         }
 
-        for &position in &move_sequence {
+                for &position in &move_sequence {
             new_game.make_move(position);
         }
 
@@ -140,7 +139,7 @@ mod tests {
     fn test_ai_creation() {
         let ai = AI::new(Player::O);
         assert_eq!(ai.player, Player::O);
-        
+
         let ai_x = AI::new(Player::X);
         assert_eq!(ai_x.player, Player::X);
     }
@@ -149,13 +148,13 @@ mod tests {
     fn test_ai_blocks_winning_move() {
         let mut game = Game::new();
         let ai = AI::new(Player::O);
-        
+
         // X threatens to win in top row
         game.make_move(1); // X
         game.make_move(4); // O (AI's previous move)
         game.make_move(2); // X
         // Now X threatens to win at position 3
-        
+
         let ai_move = ai.get_best_move(&game);
         assert_eq!(ai_move, Some(3)); // AI should block at position 3
     }
@@ -164,15 +163,15 @@ mod tests {
     fn test_ai_takes_winning_move() {
         let mut game = Game::new();
         let ai = AI::new(Player::O);
-        
+
         // Set up a scenario where AI can win
         game.make_move(1); // X
         game.make_move(4); // O
         game.make_move(2); // X
         game.make_move(5); // O
         game.make_move(7); // X
         // Now O can win at position 6
-        
+
         let ai_move = ai.get_best_move(&game);
         assert_eq!(ai_move, Some(6)); // AI should win at position 6
     }
@@ -181,7 +180,7 @@ mod tests {
     fn test_ai_chooses_valid_move_on_empty_board() {
         let game = Game::new();
         let ai = AI::new(Player::X);
-        
+
         let ai_move = ai.get_best_move(&game);
         // On an empty board, any move should be valid (1-9)
         // The AI should choose some valid position
@@ -194,13 +193,17 @@ mod tests {
     fn test_ai_no_moves_available() {
         let mut game = Game::new();
         let ai = AI::new(Player::O);
-        
+
         // Fill the board completely
         for position in 1..=9 {
-            let player = if position % 2 == 1 { Player::X } else { Player::O };
+            let _player = if position % 2 == 1 {
+                Player::X
+            } else {
+                Player::O
+            };
             game.make_move(position);
         }
-        
+
         let ai_move = ai.get_best_move(&game);
         assert_eq!(ai_move, None); // No moves available
     }
@@ -209,7 +212,7 @@ mod tests {
     fn test_minimax_prefers_winning_sooner() {
         let mut game = Game::new();
         let ai = AI::new(Player::O);
-        
+
         // Create a scenario where AI has multiple ways to win
         // AI should prefer the immediate win over a longer path to victory
         game.make_move(1); // X
@@ -218,8 +221,8 @@ mod tests {
         game.make_move(5); // O
         game.make_move(8); // X
         // AI can win immediately at position 6
-        
+
         let ai_move = ai.get_best_move(&game);
         assert_eq!(ai_move, Some(6)); // Should take the immediate win
     }
-}
+}

topics/tic-tac-toe/src/board.rs

@@ -31,9 +31,9 @@ impl Board {
         if position == 0 || position > 9 {
             return false;
         }
-        
+
         let index = position - 1;
-        
+
         if self.cells[index] == Cell::Empty {
             self.cells[index] = Cell::Occupied(player);
             true
@@ -42,14 +42,6 @@ impl Board {
         }
     }
 
-    /// Checks if a position is empty
-    pub fn is_empty(&self, position: usize) -> bool {
-        if position == 0 || position > 9 {
-            return false;
-        }
-        self.cells[position - 1] == Cell::Empty
-    }
-
     /// Gets the cell at a specific position (1-9)
     pub fn get_cell(&self, position: usize) -> Option<Cell> {
         if position == 0 || position > 9 {
@@ -90,7 +82,7 @@ impl Board {
                     Some(Cell::Occupied(Player::O)) => "O".to_string(),
                     None => "?".to_string(),
                 };
-                
+
                 print!(" {} ", display_char);
                 if col < 2 {
                     print!("|");
@@ -112,30 +104,27 @@ mod tests {
     #[test]
     fn test_new_board() {
         let board = Board::new();
-        
+
         for position in 1..=9 {
             assert_eq!(board.get_cell(position), Some(Cell::Empty));
-            assert!(board.is_empty(position));
         }
-        
+
         assert!(!board.is_full());
-        
+
         assert_eq!(board.get_empty_positions().len(), 9);
         assert_eq!(board.get_empty_positions(), vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
     }
 
     #[test]
     fn test_place_move_valid() {
         let mut board = Board::new();
-        
+
         assert!(board.place_move(5, Player::X));
         assert_eq!(board.get_cell(5), Some(Cell::Occupied(Player::X)));
-        assert!(!board.is_empty(5));
-        
+
         assert!(board.place_move(1, Player::O));
         assert_eq!(board.get_cell(1), Some(Cell::Occupied(Player::O)));
-        assert!(!board.is_empty(1));
-        
+
         assert_eq!(board.get_empty_positions().len(), 7);
         assert!(!board.get_empty_positions().contains(&1));
         assert!(!board.get_empty_positions().contains(&5));
@@ -144,66 +133,62 @@ mod tests {
     #[test]
     fn test_place_move_invalid_position() {
         let mut board = Board::new();
-        
+
         assert!(!board.place_move(0, Player::X));
         assert!(!board.place_move(10, Player::X));
-        
+
         assert_eq!(board.get_empty_positions().len(), 9);
     }
 
     #[test]
     fn test_place_move_occupied_position() {
         let mut board = Board::new();
-        
+
         assert!(board.place_move(5, Player::X));
-        
+
         assert!(!board.place_move(5, Player::O));
-        
+
         assert_eq!(board.get_cell(5), Some(Cell::Occupied(Player::X)));
     }
 
     #[test]
     fn test_get_cell_invalid_position() {
         let board = Board::new();
-        
+
         assert_eq!(board.get_cell(0), None);
         assert_eq!(board.get_cell(10), None);
     }
 
-    #[test]
-    fn test_is_empty_invalid_position() {
-        let board = Board::new();
-        
-        assert!(!board.is_empty(0));
-        assert!(!board.is_empty(10));
-    }
-
     #[test]
     fn test_is_full() {
         let mut board = Board::new();
-        
+
         assert!(!board.is_full());
-        
+
         for position in 1..=9 {
-            let player = if position % 2 == 1 { Player::X } else { Player::O };
+            let player = if position % 2 == 1 {
+                Player::X
+            } else {
+                Player::O
+            };
             board.place_move(position, player);
         }
-        
+
         assert!(board.is_full());
         assert_eq!(board.get_empty_positions().len(), 0);
     }
 
     #[test]
     fn test_get_empty_positions() {
         let mut board = Board::new();
-        
+
         let mut expected = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];
         assert_eq!(board.get_empty_positions(), expected);
-        
+
         board.place_move(1, Player::X);
         board.place_move(5, Player::O);
         board.place_move(9, Player::X);
-        
+
         expected.retain(|&x| x != 1 && x != 5 && x != 9);
         assert_eq!(board.get_empty_positions(), expected);
         assert_eq!(board.get_empty_positions(), vec![2, 3, 4, 6, 7, 8]);
@@ -214,9 +199,9 @@ mod tests {
         let mut original = Board::new();
         original.place_move(1, Player::X);
         original.place_move(5, Player::O);
-        
+
         let cloned = original.clone();
-        
+
         assert_eq!(cloned.get_cell(1), Some(Cell::Occupied(Player::X)));
         assert_eq!(cloned.get_cell(5), Some(Cell::Occupied(Player::O)));
         assert_eq!(cloned.get_empty_positions().len(), 7);
@@ -237,4 +222,4 @@ mod tests {
         assert_ne!(Cell::Empty, Cell::Occupied(Player::X));
         assert_ne!(Cell::Occupied(Player::X), Cell::Occupied(Player::O));
     }
-}
+}