Problème UTF8: Changer le texte de fin et les indications de partie

jeu.c

@@ -4,6 +4,7 @@
 #include <graph.h>
 #include "jeu.h"
 
+/* Fonction qui initialise le jeu */
 struct EtatJeu initialiserJeu(int tailleGrille, int mode) {
     struct EtatJeu etat;
     int i;
@@ -26,10 +27,12 @@ struct EtatJeu initialiserJeu(int tailleGrille, int mode) {
     return etat;
 }
 
+/* Fonction qui vérifie si deux cases sont adjacentes */
 int estCaseAdjacente(struct Position pos1, struct Position pos2) {
     return abs(pos1.x - pos2.x) <= 1 && abs(pos1.y - pos2.y) <= 1;
 }
 
+/* Fonction qui vérifie si le joueur peut déplacer son pion */
 int peutDeplacer(struct EtatJeu etatJeu, int joueur) {
     struct Position pos;
     int i, j;
@@ -54,6 +57,7 @@ int peutDeplacer(struct EtatJeu etatJeu, int joueur) {
     return 0;
 }
 
+/* Fonction qui affiche la grille de jeu */
 void dessinerGrille(struct EtatJeu etatJeu) {
     int i, j;
     int largeurFenetre = 800;
@@ -69,7 +73,7 @@ void dessinerGrille(struct EtatJeu etatJeu) {
     if(etatJeu.phase == 0) {
         sprintf(message, "Joueur %d : Placez votre pion", etatJeu.tourJoueur);
     } else if(etatJeu.phase == 1) {
-        sprintf(message, "Joueur %d : Déplacez votre pion", etatJeu.tourJoueur);
+        sprintf(message, "Joueur %d : Deplacez votre pion", etatJeu.tourJoueur);
     } else {
         sprintf(message, "Joueur %d : Bloquez une case", etatJeu.tourJoueur);
     }
@@ -105,18 +109,20 @@ void dessinerGrille(struct EtatJeu etatJeu) {
     }
 }
 
+/* Fonction qui affiche le gagnant de la partie */
 void afficherVictoire(int gagnant) {
     char message[100];
     
     EffacerEcran(CouleurParNom("white"));
     ChoisirCouleurDessin(CouleurParNom("black"));
     
-    sprintf(message, "Le joueur %d a gagné !", gagnant);
+    sprintf(message, "Le joueur %d remporte la partie !", gagnant); /* Affiche le gagnant après avoir clear la window de la partie */
     EcrireTexte(250, 300, message, 2);
     
     EcrireTexte(200, 400, "Cliquez pour retourner au menu", 1);
 }
 
+/* Fonction qui vérifie si le joueur a gagné la partie */
 int verifierVictoire(struct EtatJeu etatJeu) {
     if (etatJeu.phase == 0) {
         return 0;

jeu.h

@@ -1,11 +1,13 @@
 #ifndef JEU_H_INCLUS
 #define JEU_H_INCLUS
 
+/* Structure qui représente une position sur la grille */
 struct Position {
     int x;
     int y;
 };
 
+/* Structure qui représente l'état du jeu */
 struct EtatJeu {
     int tailleGrille;
     int mode;       
@@ -16,11 +18,22 @@ struct EtatJeu {
     int** grille;
 };
 
+/* Fonction qui initialise le jeu */
 struct EtatJeu initialiserJeu(int tailleGrille, int mode);
+
+/* Fonction qui dessine la grille de jeu */
 void dessinerGrille(struct EtatJeu etatJeu);
+
+/* Fonction qui vérifie si le joueur a gagné la partie */
 int verifierVictoire(struct EtatJeu etatJeu);
+
+/* Fonction qui affiche le gagnant de la partie */
 void afficherVictoire(int gagnant);
+
+/* Fonction qui vérifie si deux cases sont adjacentes */
 int estCaseAdjacente(struct Position pos1, struct Position pos2);
+
+/* Fonction qui vérifie si le joueur peut déplacer son pion */
 int peutDeplacer(struct EtatJeu etatJeu, int joueur);
 
 #endif /* JEU_H_INCLUS */

jeu_humain.c

@@ -2,18 +2,21 @@
 #include <stdlib.h>
 #include <graph.h>
 #include <unistd.h>
+#include "jeu.h"
 #include "jeu_humain.h"
 
+/* Fonction qui permet de jouer en mode humain */
 void jouerModeHumain(struct EtatJeu *etatJeu) {
     while (1) {
         if (SourisCliquee()) {
-            printf("Clic détecté sur la grille à : (%d, %d)\n", _X, _Y);
+            if (etatJeu->phase == 0) {
-            gererClicHumain(etatJeu);
+                gererPlacementInitial(etatJeu);
+            } else {
+                gererTourJoueur(etatJeu);
+            }
             
-            int gagnant = verifierVictoire(*etatJeu);
+            if (etatJeu->phase > 0 && !peutDeplacer(*etatJeu, etatJeu->tourJoueur)) {
-            if (gagnant != 0) {
+                afficherVictoire(etatJeu->tourJoueur == 1 ? 2 : 1);
-                afficherVictoire(gagnant);
-                printf("En attente d'un clic pour retourner au menu...\n");
                 while (!SourisCliquee()) {
                     usleep(100000);
                 }
@@ -24,35 +27,112 @@ void jouerModeHumain(struct EtatJeu *etatJeu) {
     }
 }
 
-void gererClicHumain(struct EtatJeu *etatJeu) {
+/* Fonction qui gère le placement initial du joueur 1 */
-    int x = _X;
+void gererPlacementInitial(struct EtatJeu *etatJeu) {
-    int y = _Y;
+    int x, y, i, j;
     int largeurFenetre = 800;
     int hauteurFenetre = 600;
     int marge = 50;
+    int tailleCase;
+    int startX, startY;
     
-    int tailleCase = (largeurFenetre - 2 * marge) / etatJeu->tailleGrille;
+    x = _X;
+    y = _Y;
+    
+    tailleCase = (largeurFenetre - 2 * marge) / etatJeu->tailleGrille;
     if (tailleCase * etatJeu->tailleGrille > (hauteurFenetre - 2 * marge)) {
         tailleCase = (hauteurFenetre - 2 * marge) / etatJeu->tailleGrille;
     }
     
-    int startX = (largeurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
+    startX = (largeurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
-    int startY = (hauteurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
+    startY = (hauteurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
     
     x -= startX;
     y -= startY;
     
-    int i = y / tailleCase;
+    i = y / tailleCase;
-    int j = x / tailleCase;
+    j = x / tailleCase;
     
     if (i >= 0 && i < etatJeu->tailleGrille && 
         j >= 0 && j < etatJeu->tailleGrille && 
         etatJeu->grille[i][j] == 0) {
         
         etatJeu->grille[i][j] = etatJeu->tourJoueur;
-        etatJeu->tourJoueur = (etatJeu->tourJoueur == 1) ? 2 : 1;
+        if (etatJeu->tourJoueur == 1) {
+            etatJeu->joueur1.x = j;
+            etatJeu->joueur1.y = i;
+        } else {
+            etatJeu->joueur2.x = j;
+            etatJeu->joueur2.y = i;
+        }
+        
+        if (etatJeu->tourJoueur == 2) {
+            etatJeu->phase = 1;
+            etatJeu->tourJoueur = 1;
+        } else {
+            etatJeu->tourJoueur = 2;
+        }
         
-        EffacerEcran(CouleurParNom("white"));
         dessinerGrille(*etatJeu);
     }
 }
+
+/* Fonction qui gère le tour du joueur 1 */
+void gererTourJoueur(struct EtatJeu *etatJeu) {
+    int x, y, i, j;
+    int largeurFenetre = 800;
+    int hauteurFenetre = 600;
+    int marge = 50;
+    int tailleCase;
+    int startX, startY;
+    struct Position posActuelle;
+    struct Position posCliquee;
+    
+    x = _X;
+    y = _Y;
+    
+    tailleCase = (largeurFenetre - 2 * marge) / etatJeu->tailleGrille;
+    if (tailleCase * etatJeu->tailleGrille > (hauteurFenetre - 2 * marge)) {
+        tailleCase = (hauteurFenetre - 2 * marge) / etatJeu->tailleGrille;
+    }
+    
+    startX = (largeurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
+    startY = (hauteurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
+    
+    x -= startX;
+    y -= startY;
+    
+    i = y / tailleCase;
+    j = x / tailleCase;
+    
+    posActuelle = etatJeu->tourJoueur == 1 ? etatJeu->joueur1 : etatJeu->joueur2;
+    posCliquee.x = j;
+    posCliquee.y = i;
+    
+    if (i >= 0 && i < etatJeu->tailleGrille && j >= 0 && j < etatJeu->tailleGrille) {
+        if (etatJeu->phase == 1) {
+            if (etatJeu->grille[i][j] == 0 && estCaseAdjacente(posActuelle, posCliquee)) {
+                etatJeu->grille[posActuelle.y][posActuelle.x] = 0;
+                etatJeu->grille[i][j] = etatJeu->tourJoueur;
+                
+                if (etatJeu->tourJoueur == 1) {
+                    etatJeu->joueur1.x = j;
+                    etatJeu->joueur1.y = i;
+                } else {
+                    etatJeu->joueur2.x = j;
+                    etatJeu->joueur2.y = i;
+                }
+                
+                etatJeu->phase = 2;
+                dessinerGrille(*etatJeu);
+            }
+        } else if (etatJeu->phase == 2) {
+            if (etatJeu->grille[i][j] == 0) {
+                etatJeu->grille[i][j] = 3;
+                etatJeu->phase = 1;
+                etatJeu->tourJoueur = etatJeu->tourJoueur == 1 ? 2 : 1;
+                dessinerGrille(*etatJeu);
+            }
+        }
+    }
+}

jeu_humain.h

@@ -1,9 +1,15 @@
-#ifndef JEU_HUMAIN_H
+#ifndef JEU_HUMAIN_H_INCLUS
-#define JEU_HUMAIN_H
+#define JEU_HUMAIN_H_INCLUS
 
 #include "jeu.h"
 
+/* Fonction qui permet de jouer en mode humain */
 void jouerModeHumain(struct EtatJeu *etatJeu);
-void gererClicHumain(struct EtatJeu *etatJeu);
 
-#endif
+/* Fonction qui gère le placement initial du joueur 1 */
+void gererPlacementInitial(struct EtatJeu *etatJeu);
+
+/* Fonction qui gère le tour du joueur 1 */
+void gererTourJoueur(struct EtatJeu *etatJeu);
+
+#endif /* JEU_HUMAIN_H_INCLUS */

jeu_ia.c

@@ -5,9 +5,11 @@
 #include "jeu.h"
 #include "jeu_ia.h"
 
+/* Fonction qui permet de jouer avec l'IA */
 void jouerModeIA(struct EtatJeu *etatJeu) {
     int gagnant;
     
+    /* Boucle qui permet de jouer avec l'IA */
     while (1) {
         if (etatJeu->tourJoueur == 1) {
             if (SourisCliquee()) {
@@ -28,6 +30,7 @@ void jouerModeIA(struct EtatJeu *etatJeu) {
             }
         }
         
+        /* Vérifie si le joueur a gagné la partie */
         if (etatJeu->phase > 0) {
             gagnant = verifierVictoire(*etatJeu);
             if (gagnant != 0) {
@@ -42,6 +45,7 @@ void jouerModeIA(struct EtatJeu *etatJeu) {
     }
 }
 
+/* Fonction qui gère le placement initial de l'IA */
 void gererPlacementInitialIA(struct EtatJeu *etatJeu) {
     int x, y, i, j;
     int largeurFenetre = 800;
@@ -53,11 +57,12 @@ void gererPlacementInitialIA(struct EtatJeu *etatJeu) {
     x = _X;
     y = _Y;
     
+    /* Calcul de la taille de chaque case */
     tailleCase = (largeurFenetre - 2 * marge) / etatJeu->tailleGrille;
     if (tailleCase * etatJeu->tailleGrille > (hauteurFenetre - 2 * marge)) {
         tailleCase = (hauteurFenetre - 2 * marge) / etatJeu->tailleGrille;
     }
-    
+    /* Calcul de la position de départ de la grille */
     startX = (largeurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
     startY = (hauteurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
     
@@ -67,6 +72,7 @@ void gererPlacementInitialIA(struct EtatJeu *etatJeu) {
     i = y / tailleCase;
     j = x / tailleCase;
     
+    /* Vérifie si la case est valide */
     if (i >= 0 && i < etatJeu->tailleGrille && 
         j >= 0 && j < etatJeu->tailleGrille && 
         etatJeu->grille[i][j] == 0) {
@@ -79,6 +85,7 @@ void gererPlacementInitialIA(struct EtatJeu *etatJeu) {
     }
 }
 
+/* Fonction qui gère le tour de l'IA */
 void gererTourJoueurIA(struct EtatJeu *etatJeu) {
     int x, y, i, j;
     int largeurFenetre = 800;
@@ -92,11 +99,12 @@ void gererTourJoueurIA(struct EtatJeu *etatJeu) {
     x = _X;
     y = _Y;
     
+    /* Calcul de la taille de chaque case */
     tailleCase = (largeurFenetre - 2 * marge) / etatJeu->tailleGrille;
     if (tailleCase * etatJeu->tailleGrille > (hauteurFenetre - 2 * marge)) {
         tailleCase = (hauteurFenetre - 2 * marge) / etatJeu->tailleGrille;
     }
-    
+    /* Calcul de la position de départ de la grille */
     startX = (largeurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
     startY = (hauteurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
     
@@ -106,10 +114,12 @@ void gererTourJoueurIA(struct EtatJeu *etatJeu) {
     i = y / tailleCase;
     j = x / tailleCase;
     
+    /* Position actuelle du joueur 1 */
     posActuelle = etatJeu->joueur1;
     posCliquee.x = j;
     posCliquee.y = i;
     
+    /* Vérifie si la case est valide */
     if (i >= 0 && i < etatJeu->tailleGrille && j >= 0 && j < etatJeu->tailleGrille) {
         if (etatJeu->phase == 1) {
             if (etatJeu->grille[i][j] == 0 && estCaseAdjacente(posActuelle, posCliquee)) {
@@ -131,8 +141,10 @@ void gererTourJoueurIA(struct EtatJeu *etatJeu) {
     }
 }
 
+/* Fonction qui permet de s'assurer que l'IA place son pion à un endroit valide */
 void placementIA(struct EtatJeu *etatJeu) {
     int i, j;
+    /* Boucle qui place le pion de l'IA à un endroit valide à l'aide de random */
     do {
         i = rand() % etatJeu->tailleGrille;
         j = rand() % etatJeu->tailleGrille;
@@ -146,11 +158,13 @@ void placementIA(struct EtatJeu *etatJeu) {
     dessinerGrille(*etatJeu);
 }
 
+/* Fonction qui permet à l'IA de déplacer son pion */
 void deplacementIA(struct EtatJeu *etatJeu) {
     int dx, dy;
     int newX, newY;
     int trouve = 0;
     
+    /* Boucle qui permet de trouver une case valide pour le déplacement */
     for(dx = -1; dx <= 1 && !trouve; dx++) {
         for(dy = -1; dy <= 1 && !trouve; dy++) {
             if(dx == 0 && dy == 0) continue;
@@ -174,10 +188,12 @@ void deplacementIA(struct EtatJeu *etatJeu) {
     dessinerGrille(*etatJeu);
 }
 
+/* Fonction qui permet à l'IA de placer un pion de blocage */
 void blocageIA(struct EtatJeu *etatJeu) {
     int i, j;
     int trouve = 0;
     
+    /* Boucle qui permet de trouver une case valide pour le placement du pion de blocage (avec l'aide de random)*/
     do {
         i = rand() % etatJeu->tailleGrille;
         j = rand() % etatJeu->tailleGrille;
@@ -187,4 +203,4 @@ void blocageIA(struct EtatJeu *etatJeu) {
     etatJeu->phase = 1;
     etatJeu->tourJoueur = 1;
     dessinerGrille(*etatJeu);
-}
+}

main.c

@@ -3,6 +3,8 @@
 #include <graph.h>
 #include <unistd.h>
 #include "jeu.h"
+#include "jeu_humain.h"
+#include "jeu_ia.h"
 
 void menuPrincipale() {
     int tailleGrille = 3;
@@ -10,79 +12,69 @@ void menuPrincipale() {
     char tailleStr[4];
     int besoinRedessiner = 1;
 
-    InitialiserGraphique();
+    InitialiserGraphique(); /* Initialise la fenêtre graphique  */
-    CreerFenetre(100, 100, 800, 600);
+    CreerFenetre(100, 100, 800, 600); /* Crée la fenêtre graphique */
-    ChoisirTitreFenetre("Blocus");
+    ChoisirTitreFenetre("Blocus"); /* Change le titre de la fenêtre */
     
     while (continuer) {
-        if (besoinRedessiner) { 
+        if (besoinRedessiner) { /* Si besoin de redessiner */
-            EffacerEcran(CouleurParNom("white"));
+            EffacerEcran(CouleurParNom("white")); /* Efface l'écran */
-            ChoisirCouleurDessin(CouleurParNom("black"));
+            ChoisirCouleurDessin(CouleurParNom("black")); /* 
-            EcrireTexte(300, 50, "BLOCUS", 2);
+            EcrireTexte(300, 50, "BLOCUS", 2); /* Affiche le titre du jeu */
-            EcrireTexte(250, 120, "Taille de la grille:", 1);
+            EcrireTexte(250, 120, "Taille de la grille:", 1); 
             sprintf(tailleStr, "%d", tailleGrille);
-            EcrireTexte(450, 120, tailleStr, 1);
+            EcrireTexte(450, 120, tailleStr, 1); /* Affiche la taille de la grille */
-            RemplirRectangle(500, 110, 30, 30);
-            RemplirRectangle(540, 110, 30, 30);
-            ChoisirCouleurDessin(CouleurParNom("white"));
-            EcrireTexte(510, 120, "+", 1);
-            EcrireTexte(550, 120, "-", 1);
-            ChoisirCouleurDessin(CouleurParNom("black"));
-            RemplirRectangle(250, 180, 300, 50);
-            RemplirRectangle(250, 250, 300, 50);
-            ChoisirCouleurDessin(CouleurParNom("white"));
-            EcrireTexte(280, 195, "1 Joueur (contre IA)", 1);
-            EcrireTexte(280, 265, "2 Joueurs (Humain vs Humain)", 1);
-            ChoisirCouleurDessin(CouleurParNom("black"));
-            RemplirRectangle(250, 320, 300, 50);
-            ChoisirCouleurDessin(CouleurParNom("white"));
-            EcrireTexte(320, 335, "Quitter", 1);
             
-            besoinRedessiner = 0; 
+            RemplirRectangle(500, 110, 30, 30); /* Remplit la case + */
+            RemplirRectangle(540, 110, 30, 30); /* Remplit la case - */
+            ChoisirCouleurDessin(CouleurParNom("white")); 
+            EcrireTexte(510, 120, "+", 1); /* Affiche le + */
+            EcrireTexte(550, 120, "-", 1); /* Affiche le - */
+            
+            ChoisirCouleurDessin(CouleurParNom("black")); 
+            RemplirRectangle(250, 180, 300, 50); /* Remplit la case 1 Joueur (contre IA) */ 
+            RemplirRectangle(250, 250, 300, 50); /* Remplit la case 2 Joueurs */
+            ChoisirCouleurDessin(CouleurParNom("white")); 
+            EcrireTexte(280, 195, "1 Joueur (contre IA)", 1); /* Affiche 1 Joueur (contre IA) */
+            EcrireTexte(280, 265, "2 Joueurs", 1); /* Affiche 2 Joueurs */
+            
+            ChoisirCouleurDessin(CouleurParNom("black")); 
+            RemplirRectangle(250, 320, 300, 50); /* Remplit la case Quitter */  
+            ChoisirCouleurDessin(CouleurParNom("white")); 
+            EcrireTexte(320, 335, "Quitter", 1); /* Affiche Quitter */
+            
+            besoinRedessiner = 0;
         }
 
-        if (SourisCliquee()) {
+        if (SourisCliquee()) { /* Si la souris est cliquée */
             int mouseX = _X;
             int mouseY = _Y;
-            printf("Clic détecté dans le menu à : (%d, %d)\n", mouseX, mouseY);
 
-            if (mouseX >= 500 && mouseX <= 530 && mouseY >= 110 && mouseY <= 140) {
+            if (mouseX >= 500 && mouseX <= 530 && mouseY >= 110 && mouseY <= 140) { /* Si la souris est sur la case + */
                 if (tailleGrille < 9) {
                     tailleGrille++;
                     besoinRedessiner = 1;
                 }
-            } else if (mouseX >= 540 && mouseX <= 570 && mouseY >= 110 && mouseY <= 140) {
+            } else if (mouseX >= 540 && mouseX <= 570 && mouseY >= 110 && mouseY <= 140) { /* Si la souris est sur la case - */
                 if (tailleGrille > 3) {
                     tailleGrille--;
                     besoinRedessiner = 1;
                 }
-            } else if (mouseX >= 250 && mouseX <= 550) {
+            } else if (mouseX >= 250 && mouseX <= 600) { /* Si la souris est sur la case 1 Joueur (contre IA) */
                 struct EtatJeu etatJeu;
-                if (mouseY >= 180 && mouseY <= 230 || mouseY >= 250 && mouseY <= 300) {
+                if (mouseY >= 180 && mouseY <= 230) {
-                    int mode = (mouseY >= 180 && mouseY <= 230) ? 1 : 2;
+                    etatJeu = initialiserJeu(tailleGrille, 1);
-                    etatJeu = initialiserJeu(tailleGrille, mode);
                     EffacerEcran(CouleurParNom("white"));
                     dessinerGrille(etatJeu);
-                    
+                    jouerModeIA(&etatJeu);
-                    while (1) {
+                    besoinRedessiner = 1;
-                        if (SourisCliquee()) {
+                } else if (mouseY >= 250 && mouseY <= 300) { /* Si la souris est sur la case 2 Joueurs */
-                            printf("Clic détecté sur la grille à : (%d, %d)\n", _X, _Y);
+                    etatJeu = initialiserJeu(tailleGrille, 2);
-                            gererClicSouris(&etatJeu);
+                    EffacerEcran(CouleurParNom("white"));
-                            
+                    dessinerGrille(etatJeu);
-                            int gagnant = verifierVictoire(etatJeu);
+                    jouerModeHumain(&etatJeu);
-                            if (gagnant != 0) {
+                    besoinRedessiner = 1;
-                                afficherVictoire(gagnant);
+                } else if (mouseY >= 320 && mouseY <= 370) { /* Si la souris est sur la case Quitter */
-                                printf("En attente d'un clic pour retourner au menu...\n");
-                                while (!SourisCliquee()) {
-                                    usleep(100000);
-                                }
-                                besoinRedessiner = 1;
-                                break;
-                            }
-                        }
-                        usleep(20000);
-                    }
-                } else if (mouseY >= 320 && mouseY <= 370) {
                     continuer = 0;
                 }
             }
@@ -94,6 +86,7 @@ void menuPrincipale() {
 }
 
 int main() {
+    srand(time(NULL));
     menuPrincipale();
     return 0;
 }