add cli interface

includes/jeu.h

@@ -14,6 +14,12 @@ enum CASE { VIDE = ' ', BLANC = 'B', NOIR = 'N' };
 /* Propriété globale du jeu */
 enum PLATEAU { LONGEUR = 8, LARGEUR = 8 };
 
+/* Type de joueurs */
+enum PLAYER_TYPE { HUMAIN, MINIMAX, ALPHABETA };
+
+/* Renvoie un string comportant le nom du type du joueur */
+const char *joueur_type_str(const enum PLAYER_TYPE type);
+
 /* Jeton contenant le type de case (cf. enum CASE) ainsi que la position */
 struct jeton {
     int couleur;
@@ -40,7 +46,8 @@ typedef struct jeu Jeu;
 Jeu *nouvelle_partie(void);
 
 /* Lance et joue une partie */
-void deroulement_partie(Jeu *jeu);
+void deroulement_partie(Jeu *jeu, const enum PLAYER_TYPE noir,
+                        const enum PLAYER_TYPE blanc);
 
 /* Coups possibles d'un joueur */
 struct coups {

src/jeu.c

@@ -2,6 +2,19 @@
 #include "../includes/humain.h"
 #include "../includes/minimax.h"
 
+const char *joueur_type_str(const enum PLAYER_TYPE type) {
+    switch (type) {
+    case HUMAIN:
+        return "qu'humain";
+    case MINIMAX:
+        return "que minimax";
+    case ALPHABETA:
+        return "qu'alphabêta";
+    }
+
+    return "";
+}
+
 Jeton *ajoute_jeton(const int pos_i, const int pos_j, const int couleur) {
     Jeton *jeton = malloc(sizeof(Jeton));
     jeton->couleur = couleur;
@@ -25,7 +38,8 @@ Jeu *nouvelle_partie(void) {
     return jeu;
 }
 
-void deroulement_partie(Jeu *jeu) {
+void deroulement_partie(Jeu *jeu, const enum PLAYER_TYPE type_noir,
+                        const enum PLAYER_TYPE type_blanc) {
     Joueur *tour = jeu->j1->couleur == NOIR ? jeu->j1 : jeu->j2;
 
     while (!partie_finie(jeu)) {
@@ -38,12 +52,43 @@ void deroulement_partie(Jeu *jeu) {
             printf("Tour des jetons %ss !\n", tour->nom);
 
             if (tour->couleur == NOIR) {
-                action_joueur_alphabeta(jeu, tour->couleur);
+                switch (type_noir) {
-            } else {
+                case HUMAIN:
-                printf("Coups possibles (%d) : ", possibilites->taille_liste);
+                    printf("Coups possibles (%d) : ",
+                           possibilites->taille_liste);
                     affiche_liste(possibilites->coups->premier);
                     printf("\n");
                     action_joueur_humain(jeu, tour->couleur);
+                    break;
+                case MINIMAX:
+                    action_joueur_minimax(jeu, tour->couleur);
+                    break;
+                case ALPHABETA:
+                    action_joueur_alphabeta(jeu, tour->couleur);
+                    break;
+                default:
+                    fprintf(stderr, "Erreur: Joueur noir non supporté.");
+                    exit(1);
+                }
+            } else {
+
+                switch (type_blanc) {
+                case HUMAIN:
+                    printf("Coups possibles (%d) : ",
+                           possibilites->taille_liste);
+                    affiche_liste(possibilites->coups->premier);
+                    printf("\n");
+                    action_joueur_humain(jeu, tour->couleur);
+                    break;
+                case MINIMAX:
+                    action_joueur_minimax(jeu, tour->couleur);
+                    break;
+                case ALPHABETA:
+                    action_joueur_alphabeta(jeu, tour->couleur);
+                    break;
+                default:
+                    fprintf(stderr, "Erreur: Joueur blanc non supporté.");
+                }
             }
         } else {
             printf("Pas de coup jouable.\n");

src/main.c

@@ -1,10 +1,101 @@
+#include <stdlib.h>
+#include <string.h>
+
 #include "../includes/jeu.h"
 
-int main(void) {
+/* Affiche un message d'aide */
+void help(char const progName[]);
+
+int main(int argc, char const *argv[]) {
+    enum PLAYER_TYPE noirs;
+    enum PLAYER_TYPE blancs;
+
+    if (argc < 2) { // si aucun argument
+        fprintf(stderr, "Aucun argument n'a été renseigné.\n");
+        // Affichage du message d'aide
+        help(argv[0]);
+        exit(EXIT_FAILURE);
+    }
+
+    if (argc == 2) { // si un seul argument de renseigné
+        if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0) {
+            // Affiche le message d'aide
+            help(argv[0]);
+            exit(EXIT_SUCCESS);
+        } else {
+            fprintf(stderr, "Il manque des arguments.\n");
+            // Affichage du message d'aide
+            help(argv[0]);
+            exit(EXIT_FAILURE);
+        }
+    }
+    if (argc == 3) { // s'il y a 2 arguments
+        // Concernant les noirs
+        if (strcmp(argv[1], "humain") == 0 || strcmp(argv[1], "h") == 0) {
+            noirs = HUMAIN;
+        } else {
+            if (strcmp(argv[1], "minimax") == 0 || strcmp(argv[1], "m") == 0) {
+                noirs = MINIMAX;
+            } else {
+                if (strcmp(argv[1], "alphabeta") == 0 ||
+                    strcmp(argv[1], "a") == 0) {
+                    noirs = ALPHABETA;
+                } else {
+                    fprintf(stderr, "Le joueur 1 n'a pas été reconnu.\n");
+                    // Affichage du message d'aide
+                    help(argv[0]);
+                    exit(EXIT_FAILURE);
+                }
+            }
+        }
+
+        // Concernant les blancs
+        if (strcmp(argv[2], "humain") == 0 || strcmp(argv[2], "h") == 0) {
+            blancs = HUMAIN;
+        } else {
+            if (strcmp(argv[2], "minimax") == 0 || strcmp(argv[2], "m") == 0) {
+                blancs = MINIMAX;
+            } else {
+                if (strcmp(argv[2], "alphabeta") == 0 ||
+                    strcmp(argv[2], "a") == 0) {
+                    blancs = ALPHABETA;
+                } else {
+                    fprintf(stderr, "Le joueur 2 n'a pas été reconnu.\n");
+                    // Affichage du message d'aide
+                    help(argv[0]);
+                    exit(EXIT_FAILURE);
+                }
+            }
+        }
+
         Jeu *jeu = nouvelle_partie();
-    deroulement_partie(jeu);
+
+        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);
 
         free_jeu(jeu);
 
         return EXIT_SUCCESS;
     }
+
+    fprintf(stderr, "Trop d'arguments renseignés.\n");
+    // Affichage du message d'aide
+    help(argv[0]);
+    return EXIT_FAILURE;
+}
+
+void help(char const progName[]) {
+    printf("=========================== OTELLO ===========================\n");
+    printf(
+        "-> %s <N> <B>  || Lance le jeu avec les N(oirs) et les B(blancs) :\n"
+        "\t\t\t\t- humain\t - h\n"
+        "\t\t\t\t- minimax\t - m\n"
+        "\t\t\t\t- alphabeta\t - a\n"
+        "\t\t\t\t=> exemple : %s humain alphabeta\n",
+        progName, progName);
+    printf("-> %s -h, --help || Affiche ce message d'aide.\n", progName);
+    printf("==============================================================\n");
+}