add const keyword

includes/alphabeta.h

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

includes/humain.h

@@ -6,7 +6,7 @@
 typedef struct jeu Jeu;
 
 /* Joue le tour d'un joueur humain */
-void action_joueur_humain(Jeu *jeu, int couleur);
+void action_joueur_humain(Jeu *jeu, const int couleur);
 
 /* Auxiliaire : Demande au joueur où placer son jeton */
 void _action_joueur_humain(int *ligne, int *colonne);

includes/jeu.h

@@ -23,9 +23,10 @@ struct jeton {
 typedef struct jeton Jeton;
 
 /* Ajoute un nouveau jeton */
-Jeton *ajoute_jeton(int position_i, int position_j, int couleur);
+Jeton *ajoute_jeton(const int position_i, const int position_j,
+                    const int couleur);
 
-void affiche_jeton(FILE *stream, Jeton *jeton);
+void affiche_jeton(FILE *stream, const Jeton *jeton);
 
 /* Jeu contenant nos 2 joueurs et le plateau de jeu */
 struct jeu {
@@ -49,7 +50,8 @@ struct coups {
 typedef struct coups Coups;
 
 /* Vérifie si un joueur peut jouer */
-Coups *action_possible_joueur(Jeton *plateau[LONGEUR][LARGEUR], int couleur);
+Coups *action_possible_joueur(Jeton *plateau[LONGEUR][LARGEUR],
+                              const int couleur);
 
 /* Libère les coups possibles de la mémoire  */
 void free_coups(Coups *coups);
@@ -60,10 +62,10 @@ int partie_finie(Jeu *jeu);
 /* Compte les points, change le résultat avec le gagnant ainsi que les points de
  * chacun des joueurs (Gagnant, Perdant)
  * Renvoie 0 si égalité entre les 2 joueurs */
-int selection_gagnant(Jeu *jeu, int *resultat);
+int selection_gagnant(const Jeu *jeu, int *resultat);
 
 /* Copie le jeu */
-Jeu *copie_jeu(Jeu *jeu_source);
+Jeu *copie_jeu(const Jeu *jeu_source);
 
 /* Libère le jeu de la mémoire */
 void free_jeu(Jeu *jeu);

includes/joueur.h

@@ -16,7 +16,7 @@ struct joueur {
 typedef struct joueur Joueur;
 
 /* Créer un nouveau joueur */
-Joueur *nouveau_joueur(int pion);
+Joueur *nouveau_joueur(const int pion);
 
 /* Ajoute un jeton à un joueur */
 void ajoute_jeton_joueur(Joueur *joueur, Jeton *jeton);
@@ -25,15 +25,16 @@ void ajoute_jeton_joueur(Joueur *joueur, Jeton *jeton);
 void retire_jeton_joueur(Joueur *joueur, Jeton *jeton);
 
 /* Renvoie la couleur de l'ennemi */
-int couleur_ennemi(int couleur);
+int couleur_ennemi(const int couleur);
 
 /* Gère le coup d'un joueur en faisant les changements nécessaire au jeu
  * Renvoie 0 en cas de coup illégal */
-int jeu_joueur(Jeu *jeu, int case_i, int case_j, int couleur);
+int jeu_joueur(Jeu *jeu, const int case_i, const int case_j, const int couleur);
 
 /* Auxiliaire : S'occupe de faire les changements de jetons récursivement
  * lorsqu'un joueur joue */
-void _jeu_joueur(Jeu *jeu, int case_i, int case_j, int case_i_direction,
+void _jeu_joueur(Jeu *jeu, const int case_i, const int case_j,
-                 int case_j_direction, int couleur);
+                 const int case_i_direction, const int case_j_direction,
+                 const int couleur);
 
 #endif

includes/liste.h

@@ -29,10 +29,10 @@ void ajoute_liste(Liste *liste, Element *nouvel_element);
 void supprime_liste(Element *element_actuel, Jeton *jeton);
 
 /* Affiche la liste */
-void affiche_liste(Element *element);
+void affiche_liste(const Element *element);
 
 /* Renvoie une copie de la liste */
-Liste *copie_liste(Liste *liste);
+Liste *copie_liste(const Liste *liste);
 
 /* Libère la liste en mémoire */
 void free_liste(Liste *liste);

includes/minimax.h

@@ -6,13 +6,14 @@
 #include "joueur.h"
 
 /* Joue le tour d'après l'algorithme minimax */
-void action_joueur_minimax(Jeu *jeu, int couleur);
+void action_joueur_minimax(Jeu *jeu, const int couleur);
 
 /* Décide d'une case à jouer via l'algorithme minimax */
-void _action_joueur_minimax(Jeu *jeu, int profondeur, int couleur, int gagnant,
+void _action_joueur_minimax(Jeu *jeu, int profondeur, const int couleur,
-                            int *ligne, int *colonne, int *score);
+                            const int gagnant, int *ligne, int *colonne,
+                            int *score);
 
 /* Calcule la valeur heuristique pour un coup */
-int heuristique(Jeu *jeu, int couleur);
+int heuristique(const Jeu *jeu, const int couleur);
 
 #endif

includes/plateau.h

@@ -14,12 +14,13 @@ void affiche_plateau(Jeton *plateau[LONGEUR][LARGEUR]);
 void _affiche_lettres(void);
 
 /* Vérifie si une case est jouable par un joueur */
-int case_jouable(Jeton *plateau[LONGEUR][LARGEUR], int case_i, int case_j,
+int case_jouable(Jeton *plateau[LONGEUR][LARGEUR], const int case_i,
-                 int couleur);
+                 const int case_j, const int couleur);
 
 /* Auxiliaire : Vérifie pour une direction si le coup est légal */
-int _case_jouable(Jeton *plat[LONGEUR][LARGEUR], int case_i, int case_j,
+int _case_jouable(Jeton *plateau[LONGEUR][LARGEUR], const int case_i,
-                  int case_i_direction, int case_j_direction, int couleur);
+                  const int case_j, const int case_i_direction,
+                  const int case_j_direction, const int couleur);
 
 /* Vérifie si le plateau est rempli */
 int plateau_rempli(Jeton *plateau[LONGEUR][LARGEUR]);

src/alphabeta.c

@@ -1,6 +1,6 @@
 #include "../includes/alphabeta.h"
 
-void action_joueur_alphabeta(Jeu *jeu, int couleur) {
+void action_joueur_alphabeta(Jeu *jeu, const int couleur) {
     int ligne, colonne, score = INT_MAX;
     _action_joueur_alphabeta(jeu, 9, couleur, couleur, &ligne, &colonne, &score,
                              0, VIDE);
@@ -9,8 +9,8 @@ void action_joueur_alphabeta(Jeu *jeu, int couleur) {
 }
 
 void _action_joueur_alphabeta(Jeu *jeu, int profondeur, int couleur,
-                              int gagnant, int *ligne, int *colonne, int *score,
+                              const int gagnant, int *ligne, int *colonne,
-                              int note, int qui) {
+                              int *score, const int note, const int qui) {
     Coups *possibilites = action_possible_joueur(jeu->plateau, couleur);
 
     if (!possibilites->taille_liste) {

src/humain.c

@@ -1,6 +1,6 @@
 #include "../includes/humain.h"
 
-void action_joueur_humain(Jeu *jeu, int couleur) {
+void action_joueur_humain(Jeu *jeu, const int couleur) {
     int ligne, colonne;
     _action_joueur_humain(&ligne, &colonne);
 

src/jeu.c

@@ -2,7 +2,7 @@
 #include "../includes/humain.h"
 #include "../includes/minimax.h"
 
-Jeton *ajoute_jeton(int pos_i, int pos_j, int couleur) {
+Jeton *ajoute_jeton(const int pos_i, const int pos_j, const int couleur) {
     Jeton *jeton = malloc(sizeof(Jeton));
     jeton->couleur = couleur;
     jeton->pos_i = pos_i;
@@ -11,7 +11,7 @@ Jeton *ajoute_jeton(int pos_i, int pos_j, int couleur) {
     return jeton;
 }
 
-void affiche_jeton(FILE *stream, Jeton *jeton) {
+void affiche_jeton(FILE *stream, const Jeton *jeton) {
     fprintf(stream, "%c%d", jeton->pos_j + 'A', jeton->pos_i + 1);
 }
 
@@ -65,7 +65,8 @@ void deroulement_partie(Jeu *jeu) {
     }
 }
 
-Coups *action_possible_joueur(Jeton *plat[LONGEUR][LARGEUR], int couleur) {
+Coups *action_possible_joueur(Jeton *plat[LONGEUR][LARGEUR],
+                              const int couleur) {
     Coups *coups = malloc(sizeof(Coups));
     coups->coups = nouvelle_liste();
     coups->taille_liste = 0;
@@ -100,7 +101,7 @@ int partie_finie(Jeu *jeu) {
     return reponse;
 }
 
-int selection_gagnant(Jeu *jeu, int *resultat) {
+int selection_gagnant(const Jeu *jeu, int *resultat) {
     if (jeu->j1->nb_jeton == jeu->j2->nb_jeton) {
         // Si égalité
         return 0;
@@ -121,7 +122,7 @@ int selection_gagnant(Jeu *jeu, int *resultat) {
     return 1;
 }
 
-Jeu *copie_jeu(Jeu *source) {
+Jeu *copie_jeu(const Jeu *source) {
     Jeu *res = malloc(sizeof(Jeu));
 
     // Copie de J1

src/joueur.c

@@ -1,6 +1,6 @@
 #include "../includes/joueur.h"
 
-Joueur *nouveau_joueur(int pion) {
+Joueur *nouveau_joueur(const int pion) {
     Joueur *joueur = malloc(sizeof(Joueur));
     joueur->nom = pion == NOIR ? "noir" : "blanc";
     joueur->couleur = pion;
@@ -33,9 +33,10 @@ void retire_jeton_joueur(Joueur *joueur, Jeton *jeton) {
     jeton->couleur = VIDE;
 }
 
-int couleur_ennemi(int couleur) { return couleur == NOIR ? BLANC : NOIR; }
+int couleur_ennemi(const int couleur) { return couleur == NOIR ? BLANC : NOIR; }
 
-int jeu_joueur(Jeu *jeu, int case_i, int case_j, int couleur) {
+int jeu_joueur(Jeu *jeu, const int case_i, const int case_j,
+               const int couleur) {
     int flag = 0;
 
     // Coup illégal
@@ -72,8 +73,9 @@ int jeu_joueur(Jeu *jeu, int case_i, int case_j, int couleur) {
     return flag;
 }
 
-void _jeu_joueur(Jeu *jeu, int case_i, int case_j, int case_i_direction,
+void _jeu_joueur(Jeu *jeu, const int case_i, const int case_j,
-                 int case_j_direction, int couleur) {
+                 const int case_i_direction, const int case_j_direction,
+                 const int couleur) {
     if (case_i + case_i_direction < 0 || case_i + case_i_direction >= LONGEUR ||
         case_j + case_j_direction < 0 || case_j + case_j_direction >= LARGEUR) {
         // Après une suite de pion ennemi, si l'on arrive à l'extérieur du

src/liste.c

@@ -46,7 +46,7 @@ void supprime_liste(Element *elem, Jeton *data) {
     exit(EXIT_FAILURE);
 }
 
-void affiche_liste(Element *element) {
+void affiche_liste(const Element *element) {
     if (element) {
         affiche_liste(element->suivant);
         affiche_jeton(stdout, element->jeton);
@@ -54,7 +54,7 @@ void affiche_liste(Element *element) {
     }
 }
 
-Liste *copie_liste(Liste *liste) {
+Liste *copie_liste(const Liste *liste) {
     Liste *res = nouvelle_liste();
 
     Element *element = liste->premier;

src/minimax.c

@@ -1,14 +1,15 @@
 #include "../includes/minimax.h"
 
-void action_joueur_minimax(Jeu *jeu, int couleur) {
+void action_joueur_minimax(Jeu *jeu, const int couleur) {
     int ligne, colonne, score = INT_MAX;
     _action_joueur_minimax(jeu, 5, couleur, couleur, &ligne, &colonne, &score);
 
     jeu_joueur(jeu, ligne, colonne, couleur);
 }
 
-void _action_joueur_minimax(Jeu *jeu, int profondeur, int couleur, int gagnant,
+void _action_joueur_minimax(Jeu *jeu, int profondeur, int couleur,
-                            int *ligne, int *colonne, int *score) {
+                            const int gagnant, int *ligne, int *colonne,
+                            int *score) {
     Coups *possibilites = action_possible_joueur(jeu->plateau, couleur);
 
     // Pas de coups possibles
@@ -70,7 +71,7 @@ void _action_joueur_minimax(Jeu *jeu, int profondeur, int couleur, int gagnant,
     free_coups(possibilites);
 }
 
-int heuristique(Jeu *jeu, int couleur) {
+int heuristique(const Jeu *jeu, const int couleur) {
     if (jeu->j1->couleur == couleur) {
         // Si on est le joueur 1
         return jeu->j1->nb_jeton - jeu->j2->nb_jeton;

src/plateau.c

@@ -63,8 +63,8 @@ void _affiche_lettres(void) {
     printf("\n");
 }
 
-int case_jouable(Jeton *plat[LONGEUR][LARGEUR], int case_i, int case_j,
+int case_jouable(Jeton *plat[LONGEUR][LARGEUR], const int case_i,
-                 int couleur) {
+                 const int case_j, const int couleur) {
     int flag = 0;
 
     // Coup illégal
@@ -89,8 +89,9 @@ int case_jouable(Jeton *plat[LONGEUR][LARGEUR], int case_i, int case_j,
     return flag;
 }
 
-int _case_jouable(Jeton *plat[LONGEUR][LARGEUR], int case_i, int case_j,
+int _case_jouable(Jeton *plat[LONGEUR][LARGEUR], const int case_i,
-                  int case_i_direction, int case_j_direction, int couleur) {
+                  const int case_j, const int case_i_direction,
+                  const int case_j_direction, const int couleur) {
     if (case_i + case_i_direction < 0 || case_i + case_i_direction >= LONGEUR ||
         case_j + case_j_direction < 0 || case_j + case_j_direction >= LARGEUR) {
         // Après une suite de pion ennemi, si l'on arrive à l'extérieur du