add tests

includes/alphabeta.h

@@ -4,7 +4,7 @@
 #include "minimax.h"
 
 /* Joue le tour d'après l'algorithme alpha-beta */
-void action_joueur_alphabeta(Jeu *jeu, const int couleur);
+void action_joueur_alphabeta(Jeu *jeu, const int couleur, const int profondeur);
 
 /* Décide d'une case à jouer via l'algorithme alpha-beta */
 void _action_joueur_alphabeta(Jeu *jeu, int profondeur, int couleur,

includes/jeu.h

@@ -5,6 +5,7 @@
 #include <stdlib.h>
 
 #include "liste.h"
+#include "test.h"
 
 typedef struct joueur Joueur;
 
@@ -47,7 +48,7 @@ Jeu *nouvelle_partie(void);
 
 /* Lance et joue une partie */
 void deroulement_partie(Jeu *jeu, const enum PLAYER_TYPE noir,
-                        const enum PLAYER_TYPE blanc);
+                        const enum PLAYER_TYPE blanc, const Test_Data *test);
 
 /* Coups possibles d'un joueur */
 struct coups {

includes/minimax.h

@@ -6,7 +6,7 @@
 #include "joueur.h"
 
 /* Joue le tour d'après l'algorithme minimax */
-void action_joueur_minimax(Jeu *jeu, const int couleur);
+void action_joueur_minimax(Jeu *jeu, const int couleur, const int profondeur);
 
 /* Décide d'une case à jouer via l'algorithme minimax */
 void _action_joueur_minimax(Jeu *jeu, int profondeur, const int couleur,

includes/test.h

@@ -1,6 +1,20 @@
 #ifndef OTHELLO_TEST_H
 #define OTHELLO_TEST_H 1
 
+#include <time.h>
+
+struct test_data {
+    int test;
+    int profondeur;
+};
+typedef struct test_data Test_Data;
+
+/* Initialise un Test_Data */
+Test_Data *nouveau_test_data(int test, int profondeur);
+
+/* Libère un Test_Data de la mémoire */
+void free_test_data(Test_Data *test_data);
+
 /* Run the tests */
 void run_tests(void);
 

src/alphabeta.c

@@ -1,9 +1,10 @@
 #include "../includes/alphabeta.h"
 
-void action_joueur_alphabeta(Jeu *jeu, const int couleur) {
+void action_joueur_alphabeta(Jeu *jeu, const int couleur,
+                             const int profondeur) {
     int ligne, colonne, score = INT_MAX;
-    _action_joueur_alphabeta(jeu, 9, couleur, couleur, &ligne, &colonne, &score,
+    _action_joueur_alphabeta(jeu, profondeur, couleur, couleur, &ligne,
-                             0, VIDE);
+                             &colonne, &score, 0, VIDE);
 
     jeu_joueur(jeu, ligne, colonne, couleur);
 }

src/jeu.c

@@ -39,17 +39,22 @@ Jeu *nouvelle_partie(void) {
 }
 
 void deroulement_partie(Jeu *jeu, const enum PLAYER_TYPE type_noir,
-                        const enum PLAYER_TYPE type_blanc) {
+                        const enum PLAYER_TYPE type_blanc,
+                        const Test_Data *test) {
     Joueur *tour = jeu->j1->couleur == NOIR ? jeu->j1 : jeu->j2;
 
     while (!partie_finie(jeu)) {
-        affiche_plateau(jeu->plateau);
+        if (!test->test) {
+            affiche_plateau(jeu->plateau);
+        }
 
         Coups *possibilites =
             action_possible_joueur(jeu->plateau, tour->couleur);
         if (possibilites->taille_liste > 0) {
             // Si le joueur peut jouer
-            printf("Tour des jetons %ss !\n", tour->nom);
+            if (!test->test) {
+                printf("Tour des jetons %ss !\n", tour->nom);
+            }
 
             if (tour->couleur == NOIR) {
                 switch (type_noir) {
@@ -61,10 +66,11 @@ void deroulement_partie(Jeu *jeu, const enum PLAYER_TYPE type_noir,
                     action_joueur_humain(jeu, tour->couleur);
                     break;
                 case MINIMAX:
-                    action_joueur_minimax(jeu, tour->couleur);
+                    action_joueur_minimax(jeu, tour->couleur, test->profondeur);
                     break;
                 case ALPHABETA:
-                    action_joueur_alphabeta(jeu, tour->couleur);
+                    action_joueur_alphabeta(jeu, tour->couleur,
+                                            test->profondeur);
                     break;
                 default:
                     fprintf(stderr, "Erreur: Joueur noir non supporté.");
@@ -81,17 +87,20 @@ void deroulement_partie(Jeu *jeu, const enum PLAYER_TYPE type_noir,
                     action_joueur_humain(jeu, tour->couleur);
                     break;
                 case MINIMAX:
-                    action_joueur_minimax(jeu, tour->couleur);
+                    action_joueur_minimax(jeu, tour->couleur, test->profondeur);
                     break;
                 case ALPHABETA:
-                    action_joueur_alphabeta(jeu, tour->couleur);
+                    action_joueur_alphabeta(jeu, tour->couleur,
+                                            test->profondeur);
                     break;
                 default:
                     fprintf(stderr, "Erreur: Joueur blanc non supporté.");
                 }
             }
         } else {
-            printf("Pas de coup jouable.\n");
+            if (!test->test) {
+                printf("Pas de coup jouable.\n");
+            }
         }
         free_coups(possibilites);
 
@@ -99,15 +108,19 @@ void deroulement_partie(Jeu *jeu, const enum PLAYER_TYPE type_noir,
         tour = jeu->j1->couleur == tour->couleur ? jeu->j2 : jeu->j1;
     }
 
-    affiche_plateau(jeu->plateau);
+    if (!test->test) {
-    int resultat[3];
+        affiche_plateau(jeu->plateau);
-    if (selection_gagnant(jeu, resultat)) {
+
-        printf("Fin de partie ! Le joueur %s a gagné %d contre %d !\n",
+        int resultat[3];
-               jeu->j1->couleur == resultat[0] ? jeu->j1->nom : jeu->j2->nom,
+        if (selection_gagnant(jeu, resultat)) {
-               resultat[1], resultat[2]);
+            printf("Fin de partie ! Le joueur %s a gagné %d contre %d !\n",
-    } else {
+                   jeu->j1->couleur == resultat[0] ? jeu->j1->nom
-        printf("Égalité parfaite, %d contre %d !\n", jeu->j1->nb_jeton,
+                                                   : jeu->j2->nom,
-               jeu->j2->nb_jeton);
+                   resultat[1], resultat[2]);
+        } else {
+            printf("Égalité parfaite, %d contre %d !\n", jeu->j1->nb_jeton,
+                   jeu->j2->nb_jeton);
+        }
     }
 }
 

src/main.c

@@ -74,14 +74,16 @@ int main(int argc, char const *argv[]) {
         }
 
         Jeu *jeu = nouvelle_partie();
+        Test_Data *test = nouveau_test_data(0, 3);
 
         printf("Le jeu commence avec les noirs en tant %s et les blancs en "
                "tant %s.\n",
                joueur_type_str(noirs), joueur_type_str(blancs));
 
-        deroulement_partie(jeu, noirs, blancs);
+        deroulement_partie(jeu, noirs, blancs, test);
 
         free_jeu(jeu);
+        free_test_data(test);
 
         return EXIT_SUCCESS;
     }

src/minimax.c

@@ -1,8 +1,9 @@
 #include "../includes/minimax.h"
 
-void action_joueur_minimax(Jeu *jeu, const int couleur) {
+void action_joueur_minimax(Jeu *jeu, const int couleur, const int profondeur) {
     int ligne, colonne, score = INT_MAX;
-    _action_joueur_minimax(jeu, 5, couleur, couleur, &ligne, &colonne, &score);
+    _action_joueur_minimax(jeu, profondeur, couleur, couleur, &ligne, &colonne,
+                           &score);
 
     jeu_joueur(jeu, ligne, colonne, couleur);
 }

src/test.c

@@ -1,3 +1,34 @@
-#include "../includes/test.h"
+#include "../includes/jeu.h"
 
-void run_tests(void) {}
+Test_Data *nouveau_test_data(int test, int profondeur) {
+    Test_Data *res = malloc(sizeof(Test_Data));
+
+    res->test = test;
+    res->profondeur = profondeur;
+
+    return res;
+}
+
+void free_test_data(Test_Data *test_data) { free(test_data); }
+
+void run_tests(void) {
+    printf("Test alphabeta...\n");
+    Jeu *jeu = nouvelle_partie();
+
+    Test_Data *test = nouveau_test_data(1, 8);
+
+    clock_t ta, td;
+
+    td = clock();
+
+    // Lance le jeu en mode test avec 2 alpha-bêta
+    deroulement_partie(jeu, ALPHABETA, ALPHABETA, test);
+
+    ta = clock();
+
+    printf("Alphabêta : %ld\n", ta - td);
+
+    free_jeu(jeu);
+
+    free_test_data(test);
+}