Add Minimax AI mode

Signed-off-by: estelle.tamalet <estelle.tamalet@etu.umontpellier.fr>

Author: estelle-tamalet

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

@@ -98,4 +98,74 @@ impl TicTacToe {
         }
         empty_cells
     }
+
+    pub fn unplace(&mut self, row: usize, col: usize) {
+        if row < SIZE && col < SIZE {
+            self.board[row][col] = Cell::Empty;
+        }
+    }
+
+    pub fn evaluate(&self) -> i32 {
+        if let Some(winner) = self.check_winner() {
+            match winner {
+                Cell::O => 10,  // L'ordinateur (O) gagne
+                Cell::X => -10, // Le joueur humain (X) gagne
+                Cell::Empty => 0,
+            }
+        } else {
+            0 // Match nul ou jeu non terminé
+        }
+    }
+
+    pub fn minimax(&mut self, is_maximizing: bool) -> i32 {
+        // Vérifier si le jeu est terminé
+        let score = self.evaluate();
+        if score == 10 || score == -10 {
+            return score;
+        }
+
+        if self.is_full() {
+            return 0; // Match nul
+        }
+
+        if is_maximizing {
+            // Tour de l'ordinateur (O) - maximiser le score
+            let mut best_score = i32::MIN;
+            for (row, col) in self.get_empty_cells() {
+                self.board[row][col] = Cell::O;
+                let score = self.minimax(false);
+                self.board[row][col] = Cell::Empty;
+                best_score = best_score.max(score);
+            }
+            best_score
+        } else {
+            // Tour du joueur (X) - minimiser le score
+            let mut best_score = i32::MAX;
+            for (row, col) in self.get_empty_cells() {
+                self.board[row][col] = Cell::X;
+                let score = self.minimax(true);
+                self.board[row][col] = Cell::Empty;
+                best_score = best_score.min(score);
+            }
+            best_score
+        }
+    }
+
+    pub fn find_best_move(&mut self) -> Option<(usize, usize)> {
+        let mut best_score = i32::MIN;
+        let mut best_move = None;
+
+        for (row, col) in self.get_empty_cells() {
+            self.board[row][col] = Cell::O;
+            let score = self.minimax(false);
+            self.board[row][col] = Cell::Empty;
+
+            if score > best_score {
+                best_score = score;
+                best_move = Some((row, col));
+            }
+        }
+
+        best_move
+    }
 }

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

@@ -8,7 +8,8 @@ fn main() {
     println!("=== Tic-Tac-Toe ===");
     println!("Choisissez le mode de jeu :");
     println!("1. Deux joueurs");
-    println!("2. Contre l'ordinateur");
+    println!("2. Contre l'ordinateur (aléatoire)");
+    println!("3. Contre l'ordinateur (Minimax - imbattable)");
     print!("> ");
     io::stdout().flush().unwrap();
 
@@ -19,6 +20,7 @@ fn main() {
     match mode {
         "1" => play_two_players(),
         "2" => play_against_computer(),
+        "3" => play_against_minimax(),
         _ => {
             println!("Mode invalide ! Relancez le jeu.");
         }
@@ -200,3 +202,102 @@ fn play_against_computer() {
     game.display();
     println!("\nMerci d'avoir joué !");
 }
+
+fn play_against_minimax() {
+    let mut game = TicTacToe::new();
+
+    println!("\n=== Mode Contre l'Ordinateur (Minimax) ===");
+    println!("Vous êtes X, l'ordinateur est O");
+    println!("L'ordinateur utilise l'algorithme Minimax - il est imbattable !");
+    println!("Entrez les coordonnées comme : ligne colonne (1-3)");
+    println!("Exemple : 1 1 pour le coin supérieur gauche\n");
+
+    loop {
+        game.display();
+
+        // Vérifier victoire ou match nul
+        if let Some(winner) = game.check_winner() {
+            match winner {
+                Cell::X => println!("Vous avez gagné ! Incroyable !"),
+                Cell::O => println!("L'ordinateur a gagné !"),
+                _ => {}
+            }
+            break;
+        }
+
+        if game.is_full() {
+            println!("Match nul ! Bien joué !");
+            break;
+        }
+
+        // Tour du joueur humain (X)
+        println!("Votre tour (X), entrez votre coup (ligne colonne) :");
+        print!("> ");
+        io::stdout().flush().unwrap();
+
+        let mut input = String::new();
+        io::stdin().read_line(&mut input).unwrap();
+
+        let coords: Vec<&str> = input.trim().split_whitespace().collect();
+        if coords.len() != 2 {
+            println!("Entrée invalide ! Utilisez le format : ligne colonne (ex: 1 1)");
+            continue;
+        }
+
+        let row = match coords[0].parse::<usize>() {
+            Ok(r) if r >= 1 && r <= 3 => r - 1,
+            Ok(_) => {
+                println!("Ligne invalide ! Utilisez un nombre entre 1 et 3.");
+                continue;
+            }
+            Err(_) => {
+                println!("Ligne invalide !");
+                continue;
+            }
+        };
+
+        let col = match coords[1].parse::<usize>() {
+            Ok(c) if c >= 1 && c <= 3 => c - 1,
+            Ok(_) => {
+                println!("Colonne invalide ! Utilisez un nombre entre 1 et 3.");
+                continue;
+            }
+            Err(_) => {
+                println!("Colonne invalide !");
+                continue;
+            }
+        };
+
+        if !game.place(row, col, Cell::X) {
+            println!("Coup invalide ! La case est déjà occupée.");
+            continue;
+        }
+
+        // Vérifier victoire après coup du joueur
+        if let Some(winner) = game.check_winner() {
+            game.display();
+            if winner == Cell::X {
+                println!("Vous avez gagné ! Incroyable !");
+            }
+            break;
+        }
+
+        if game.is_full() {
+            game.display();
+            println!("Match nul ! Bien joué !");
+            break;
+        }
+
+        // Tour de l'ordinateur (O) avec Minimax
+        println!("\nL'ordinateur calcule le meilleur coup (Minimax)...");
+        std::thread::sleep(std::time::Duration::from_millis(500));
+
+        if let Some((comp_row, comp_col)) = game.find_best_move() {
+            game.place(comp_row, comp_col, Cell::O);
+            println!("L'ordinateur joue en ({}, {})", comp_row + 1, comp_col + 1);
+        }
+    }
+
+    game.display();
+    println!("\nMerci d'avoir joué !");
+}