diff --git a/includes/minimax.h b/includes/minimax.h
index c8b3a88..8d02536 100644
--- a/includes/minimax.h
+++ b/includes/minimax.h
@@ -11,10 +11,10 @@ typedef struct jeu Jeu;
 void action_joueur_minimax(Jeu *jeu, int couleur);
 
 /* Implémentation de Minimax */
-int minimax(Jeu *jeu, int profondeur, Coups *positions, Jeton coup_choisi,
-            int joueur, int joueur_gagnant);
+int minimax(int profondeur, Jeton coup_choisi, int joueur, Jeu *jeu,
+            Coups *positions, int joueur_gagnant);
 
 /* Calcule la valeur heuristique pour un coup */
-int heuristique(Jeu *jeu, Jeton coup_choisi);
+int heuristique(Jeu *jeu, Jeton coup_choisi, int couleur);
 
 #endif
diff --git a/src/minimax.c b/src/minimax.c
index 4b804eb..b3c567b 100644
--- a/src/minimax.c
+++ b/src/minimax.c
@@ -3,10 +3,8 @@
 void action_joueur_minimax(Jeu *jeu, int couleur) {
     Coups *possibilites = action_possible_joueur(jeu->plateau, couleur);
 
-    // On fait une copie du plateau actuel
-
-    int rep_minimax = minimax(jeu, 3, possibilites,
-                              *possibilites->coups->premier->jeton, couleur, 1);
+    int rep_minimax = minimax(3, *possibilites->coups->premier->jeton, couleur,
+                              jeu, possibilites, couleur);
 
     printf("rep_minimax: %d\n", rep_minimax);
 
@@ -20,51 +18,59 @@ void action_joueur_minimax(Jeu *jeu, int couleur) {
     jeu_joueur(jeu, ligne, colonne, couleur);
 }
 
-int minimax(Jeu *jeu, int profondeur, Coups *positions, Jeton coup_choisi,
-            int joueur, int joueur_gagnant) {
+int minimax(int profondeur, Jeton coup_choisi, int joueur, Jeu *jeu,
+            Coups *positions, int joueur_gagnant) {
     if (profondeur == 0) {
-        return heuristique(jeu, coup_choisi);
+        return heuristique(jeu, coup_choisi, joueur);
     }
 
     int value;
-    if (joueur_gagnant) {
+    if (joueur_gagnant == joueur) {
+        // Si c'est nous, le joueur qui doit gagner (J1)
         value = INT_MIN;
-        Element *tmp = positions->coups->premier;
-        while (tmp) {
+
+        Element *coup_possible = positions->coups->premier;
+        while (coup_possible) {
             Jeu *jeu_copie = copie_jeu(jeu);
             Coups *possibilites =
                 action_possible_joueur(jeu_copie->plateau, joueur);
 
-            value = max(value, minimax(jeu_copie, profondeur - 1, possibilites,
-                                       *tmp->jeton, joueur, 0));
+            value = max(value,
+                        minimax(profondeur - 1, *coup_possible->jeton, joueur,
+                                jeu_copie, possibilites, joueur_gagnant));
 
             free_coups(possibilites);
             free_jeu(jeu_copie);
-            tmp = tmp->suivant;
+
+            coup_possible = coup_possible->suivant;
         }
     } else {
+        // Si c'est l'ennemi, le joueur qui doit perdre (J2)
         value = INT_MAX;
-        Element *tmp = positions->coups->premier;
-        while (tmp) {
+        int ennemi = couleur_ennemi(joueur);
+
+        Element *coup_possible = positions->coups->premier;
+        while (coup_possible) {
             Jeu *jeu_copie = copie_jeu(jeu);
             Coups *possibilites =
-                action_possible_joueur(jeu_copie->plateau, joueur);
+                action_possible_joueur(jeu_copie->plateau, ennemi);
 
-            value = max(value, minimax(jeu_copie, profondeur - 1, possibilites,
-                                       *tmp->jeton, joueur, 1));
+            value = min(value,
+                        minimax(profondeur - 1, *coup_possible->jeton, ennemi,
+                                jeu_copie, possibilites, joueur_gagnant));
 
             free_coups(possibilites);
             free_jeu(jeu_copie);
-            tmp = tmp->suivant;
+
+            coup_possible = coup_possible->suivant;
         }
     }
 
     return value;
 }
 
-int heuristique(Jeu *jeu, Jeton coup_choisi) {
-    if (jeu_joueur(jeu, coup_choisi.pos_i, coup_choisi.pos_j,
-                   coup_choisi.couleur)) {
+int heuristique(Jeu *jeu, Jeton coup_choisi, int couleur) {
+    if (jeu_joueur(jeu, coup_choisi.pos_i, coup_choisi.pos_j, couleur)) {
         return 0;
     }
 
@@ -74,35 +80,3 @@ int heuristique(Jeu *jeu, Jeton coup_choisi) {
 
     exit(EXIT_FAILURE);
 }
-
-Jeu *copie_jeu(Jeu *source) {
-    Jeu *res = malloc(sizeof(Jeu));
-
-    // Copie J1
-    res->j1 = malloc(sizeof(Joueur));
-    res->j1->nom = source->j1->nom;
-    res->j1->couleur = source->j1->couleur;
-    res->j1->liste_jeton = copie_liste(source->j1->liste_jeton);
-    res->j1->nb_jeton = source->j1->nb_jeton;
-
-    // Copie J2
-    res->j2 = malloc(sizeof(Joueur));
-    res->j1->nom = source->j1->nom;
-    res->j2->couleur = source->j2->couleur;
-    res->j2->liste_jeton = copie_liste(source->j2->liste_jeton);
-    res->j2->nb_jeton = source->j2->nb_jeton;
-
-    // Copie plateau
-    for (int i = 0; i < LONGEUR; ++i) {
-        for (int j = 0; j < LARGEUR; ++j) {
-            Jeton *jeton = malloc(sizeof(Jeton));
-            jeton->couleur = source->plateau[i][j]->couleur;
-            jeton->pos_i = source->plateau[i][j]->pos_i;
-            jeton->pos_j = source->plateau[i][j]->pos_j;
-
-            res->plateau[i][j] = jeton;
-        }
-    }
-
-    return res;
-}