feat : add interactive cli

Author: aurianecodebien

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

@@ -17,7 +17,7 @@ impl AI {
     /// Returns the position (0-8) of the best move
     pub fn find_best_move(&self, game: &Game) -> Option<usize> {
         let available_moves = game.available_moves();
-        
+
         if available_moves.is_empty() {
             return None;
         }
@@ -40,23 +40,23 @@ impl AI {
     }
 
     /// Minimax algorithm with depth tracking
-    /// 
+    ///
     /// # Arguments
     /// * `game` - The current game state
     /// * `depth` - Current depth in the game tree
     /// * `is_maximizing` - True if maximizing player (AI), false if minimizing (Human)
-    /// 
+    ///
     /// # Returns
     /// The score of the board state
     fn minimax(&self, game: &mut Game, depth: i32, is_maximizing: bool) -> i32 {
         // Terminal state: check if game is over
         let score = game.evaluate();
-        
+
         // If AI won, return score minus depth (prefer faster wins)
         if score == 10 {
             return score - depth;
         }
-        
+
         // If Human won, return score plus depth (prefer slower losses)
         if score == -10 {
             return score + depth;
@@ -71,24 +71,24 @@ impl AI {
         if is_maximizing {
             // Maximizing player (AI)
             let mut best_score = i32::MIN;
-            
+
             for &position in &available_moves {
                 let mut game_clone = self.simulate_move(game, position, Player::AI);
                 let score = self.minimax(&mut game_clone, depth + 1, false);
                 best_score = best_score.max(score);
             }
-            
+
             best_score
         } else {
             // Minimizing player (Human)
             let mut best_score = i32::MAX;
-            
+
             for &position in &available_moves {
                 let mut game_clone = self.simulate_move(game, position, Player::Human);
                 let score = self.minimax(&mut game_clone, depth + 1, true);
                 best_score = best_score.min(score);
             }
-            
+
             best_score
         }
     }
@@ -97,17 +97,17 @@ impl AI {
     fn simulate_move(&self, game: &Game, position: usize, player: Player) -> Game {
         // Create a copy of the current game using the board state
         let mut new_board = Board::new();
-        
+
         // Copy the current board state
         for i in 0..9 {
             if let Some(crate::types::Cell::Occupied(p)) = game.board().get(i) {
                 new_board.make_move(i, p);
             }
         }
-        
+
         // Make the new move on the copied board
         new_board.make_move(position, player);
-        
+
         // Create a new game with this board state
         // We need to use Game::from_board or similar
         // For now, let's create a helper in Game
@@ -134,12 +134,12 @@ mod tests {
     fn test_ai_blocks_winning_move() {
         let mut game = Game::new();
         let ai = AI::new();
-        
+
         // Human has two in a row
         game.make_move(0); // Human X at position 0
         game.make_move(3); // AI O at position 3
         game.make_move(1); // Human X at position 1
-        
+
         // AI should block position 2 to prevent human win
         let best_move = ai.find_best_move(&game);
         assert_eq!(best_move, Some(2));
@@ -149,14 +149,14 @@ mod tests {
     fn test_ai_takes_winning_move() {
         let mut game = Game::new();
         let ai = AI::new();
-        
+
         // Setup: AI has two in a row
         game.make_move(0); // Human X
         game.make_move(3); // AI O
         game.make_move(1); // Human X
         game.make_move(4); // AI O
         game.make_move(8); // Human X
-        
+
         // AI should take position 5 to win
         let best_move = ai.find_best_move(&game);
         assert_eq!(best_move, Some(5));
@@ -166,7 +166,7 @@ mod tests {
     fn test_ai_finds_move_on_empty_board() {
         let game = Game::new();
         let ai = AI::new();
-        
+
         // AI should find a valid move
         let best_move = ai.find_best_move(&game);
         assert!(best_move.is_some());

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

@@ -26,7 +26,7 @@ impl Board {
         if position >= 9 {
             return false;
         }
-        
+
         if self.cells[position].is_empty() {
             self.cells[position] = Cell::Occupied(player);
             true

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

@@ -1,8 +1,113 @@
-mod types;
+mod ai;
 mod board;
 mod game;
-mod ai;
+mod types;
+
+use ai::AI;
+use game::{Game, GameState};
+use std::io::{self, Write};
+use types::Player;
 
 fn main() {
-    println!("Tic-Tac-Toe game - Coming soon!");
+    println!("=================================");
+    println!("   Welcome to Tic-Tac-Toe!");
+    println!("=================================");
+    println!();
+    println!("You are X, AI is O");
+    println!("Enter positions 1-9 as shown:");
+    println!();
+    display_position_guide();
+    println!();
+
+    let mut game = Game::new();
+    let ai = AI::new();
+
+    loop {
+        // Display the current board
+        game.board().display();
+
+        // Check game state
+        match game.state() {
+            GameState::Won(Player::Human) => {
+                println!("🎉 Congratulations! You won!");
+                break;
+            }
+            GameState::Won(Player::AI) => {
+                println!("💻 AI wins! Better luck next time!");
+                break;
+            }
+            GameState::Draw => {
+                println!("🤝 It's a draw! Well played!");
+                break;
+            }
+            GameState::InProgress => {
+                // Game continues
+            }
+        }
+
+        // Current player's turn
+        if game.current_player() == Player::Human {
+            // Human turn
+            println!("Your turn (X)");
+            let position = get_human_move(&game);
+
+            if !game.make_move(position) {
+                println!("❌ Invalid move! Try again.");
+                continue;
+            }
+        } else {
+            // AI turn
+            println!("AI is thinking... 🤔");
+
+            if let Some(position) = ai.find_best_move(&game) {
+                game.make_move(position);
+                println!("AI played position {}", position + 1);
+            } else {
+                println!("❌ Error: AI couldn't find a move!");
+                break;
+            }
+        }
+    }
+
+    println!();
+    println!("Thanks for playing!");
+}
+
+/// Gets a valid move from the human player
+fn get_human_move(game: &Game) -> usize {
+    loop {
+        print!("Enter position (1-9): ");
+        io::stdout().flush().unwrap();
+
+        let mut input = String::new();
+        io::stdin()
+            .read_line(&mut input)
+            .expect("Failed to read line");
+
+        // Try to parse the input
+        match input.trim().parse::<usize>() {
+            Ok(num) if (1..=9).contains(&num) => {
+                let position = num - 1; // Convert to 0-indexed
+
+                // Check if position is available
+                if game.available_moves().contains(&position) {
+                    return position;
+                } else {
+                    println!("❌ That position is already taken! Try another.");
+                }
+            }
+            _ => {
+                println!("❌ Invalid input! Please enter a number between 1 and 9.");
+            }
+        }
+    }
+}
+
+/// Displays the position guide (how positions are numbered)
+fn display_position_guide() {
+    println!("   1 | 2 | 3");
+    println!("  -----------");
+    println!("   4 | 5 | 6");
+    println!("  -----------");
+    println!("   7 | 8 | 9");
 }