From 99fa3af788ee61a2fbf438be59d6c1cdf3acf37c Mon Sep 17 00:00:00 2001
From: Mylloon <kennel.anri@tutanota.com>
Date: Sat, 19 Nov 2022 11:40:52 +0100
Subject: [PATCH] start minimax impl

---
 includes/minimax.h | 13 +++++++-
 src/minimax.c      | 83 +++++++++++++++++++++++++++-------------------
 2 files changed, 61 insertions(+), 35 deletions(-)

diff --git a/includes/minimax.h b/includes/minimax.h
index 2f14511..c729371 100644
--- a/includes/minimax.h
+++ b/includes/minimax.h
@@ -1,6 +1,9 @@
 #ifndef OTHELLO_MINIMAX_H
 #define OTHELLO_MINIMAX_H 1
 
+#include <limits.h>
+#include <string.h>
+
 #include "joueur.h"
 
 typedef struct jeu Jeu;
@@ -9,6 +12,14 @@ typedef struct jeu Jeu;
 void action_joueur_minimax(Jeu *jeu, int couleur);
 
 /* Implémentation de Minimax */
-/* Jeton *minimax(int profondeur, Coups *positions, int joueur); */
+int minimax(Jeton *plateau[LONGEUR][LARGEUR], int profondeur, Coups *positions,
+            Jeton coup_choisi, int joueur, int joueur_gagnant);
+
+/* Calcule la valeur heuristique pour un coup */
+int heuristique(Jeton *plateau[LONGEUR][LARGEUR], Jeton coup_choisi);
+
+/* Copie le plateau */
+void copie_plateau(Jeton *plateau_source[LONGEUR][LARGEUR],
+                   Jeton *plateau_destination[LONGEUR][LARGEUR]);
 
 #endif
diff --git a/src/minimax.c b/src/minimax.c
index 656956d..f29b736 100644
--- a/src/minimax.c
+++ b/src/minimax.c
@@ -1,47 +1,62 @@
 #include "../includes/minimax.h"
 
 void action_joueur_minimax(Jeu *jeu, int couleur) {
-    // TODO
+    Coups *possibilites = action_possible_joueur(jeu->plateau, couleur);
+
+    // On fait une copie du plateau actuel
+    Jeton *plateau[LONGEUR][LARGEUR];
+    copie_plateau(jeu->plateau, plateau);
+
+    int rep_minimax = minimax(plateau, 3, possibilites,
+                              *possibilites->coups->premier->jeton, couleur, 1);
+
+    free_coups(possibilites);
+
+    printf("-> %d\n", rep_minimax);
+
+    // Crash temporaire
+    exit(1);
+
     int ligne = -1, colonne = -1;
 
     jeu_joueur(jeu, ligne, colonne, couleur);
 }
 
-/* Jeton *h(Jeton *p) {
-    // TODO ??
-    return p;
-}
-
-Jeton *_minimax(Element *element) {
-    return max(minimax(element->suivant));
-}
-
-Jeton *minimax(int profondeur, Coups *positions, int joueur) {
-
-    if (positions->taille_liste == 1) {
-        // TODO ??
-        return h(positions->coups->premier->jeton);
-    }
-
-    // Profondeur maximale
+int minimax(Jeton *plateau[LONGEUR][LARGEUR], int profondeur, Coups *positions,
+            Jeton coup_choisi, int joueur, int joueur_gagnant) {
     if (profondeur == 0) {
-        // TODO ??
-        return h(positions->coups->premier->jeton);
+        return heuristique(plateau, coup_choisi);
     }
 
-    return _minimax(positions->coups->premier);
+    int value;
+    if (joueur_gagnant) {
+        value = INT_MIN;
+        Element *tmp = positions->coups->premier;
+        while (tmp) {
+            value = max(value, minimax(plateau, profondeur - 1, positions,
+                                       *tmp->jeton, joueur, 0));
 
-    // Joueur 1 = MAX
-    // Joueur 2 = MIN
+            tmp = tmp->suivant;
+        }
+    } else {
+        value = INT_MAX;
+        Element *tmp = positions->coups->premier;
+        while (tmp) {
+            value = max(value, minimax(plateau, profondeur - 1, positions,
+                                       *tmp->jeton, joueur, 1));
 
-    // minimax(profondeur n, position p, joueur J)
-    //     - si p est terminale
-    //         return h*(p)
-    //     - si n = 0 # On a atteint la profondeur maximale
-    //         return h(p)
-    //     - sinon, soit p1, ..., pm les m positions accessibles depuis p
-    //         - si J = MAX
-    //             return max minimax(n - 1, pi, MIN) # 1 <= i <= m
-    //         - si J = MIN
-    //             return min minimax(n - 1, pi, MAX) # 1 <= 1 <= m
-} */
+            tmp = tmp->suivant;
+        }
+    }
+
+    return value;
+}
+
+int heuristique(Jeton *plateau[LONGEUR][LARGEUR], Jeton coup_choisi) {
+    return 0;
+}
+
+void copie_plateau(Jeton *source[LONGEUR][LARGEUR],
+                   Jeton *destination[LONGEUR][LARGEUR]) {
+    memcpy(destination, source, sizeof(*source));
+}