Fix

include/jeu.h

@@ -0,0 +1,40 @@
+#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;       
+    int tourJoueur;
+    int phase;
+    struct Position joueur1;
+    struct Position joueur2;
+    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 */

include/jeu_humain.h

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

include/jeu_ia.h

@@ -0,0 +1,24 @@
+#ifndef JEU_IA_H_INCLUS
+#define JEU_IA_H_INCLUS
+
+#include "jeu.h"
+
+/* Fonction qui gère le mode IA     */
+void jouerModeIA(struct EtatJeu *etatJeu);
+
+/* Fonction qui gère le placement initial IA */
+void gererPlacementInitialIA(struct EtatJeu *etatJeu);
+
+/* Fonction qui gère le tour du joueur IA */
+void gererTourJoueurIA(struct EtatJeu *etatJeu);
+
+/* Fonction qui gère le placement de l'IA */
+void placementIA(struct EtatJeu *etatJeu);
+
+/* Fonction qui gère le déplacement de l'IA */
+void deplacementIA(struct EtatJeu *etatJeu);
+
+/* Fonction qui gère le blocage de l'IA */
+void blocageIA(struct EtatJeu *etatJeu);
+
+#endif /* JEU_IA_H_INCLUS */

src/jeu.c

@@ -0,0 +1,149 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <graph.h>
+#include "jeu.h"
+
+/* Fonction qui initialise le jeu */
+struct EtatJeu initialiserJeu(int tailleGrille, int mode) {
+    struct EtatJeu etat;
+    int i;
+    
+    etat.tailleGrille = tailleGrille;
+    etat.mode = mode;
+    etat.tourJoueur = 1;
+    etat.phase = 0;
+    etat.joueur1.x = -1;
+    etat.joueur1.y = -1;
+    etat.joueur2.x = -1;
+    etat.joueur2.y = -1;
+    
+    /* Alloue la mémoire pour la grille de jeu */
+    etat.grille = malloc(tailleGrille * sizeof(int*));
+    /* Pour chaque ligne de la grille */
+    for(i = 0; i < tailleGrille; i++) {
+        /* Alloue la mémoire pour la ligne et l'initialise à 0 */
+        etat.grille[i] = malloc(tailleGrille * sizeof(int));
+        memset(etat.grille[i], 0, tailleGrille * sizeof(int));
+    }
+    
+    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;
+    int newX, newY;
+    
+    /* Récupère la position du pion du joueur actuel */
+    pos = joueur == 1 ? etatJeu.joueur1 : etatJeu.joueur2;
+    
+    /* Parcourt toutes les cases adjacentes (8 directions possibles) */
+    for(i = -1; i <= 1; i++) {
+        for(j = -1; j <= 1; j++) {
+            /* Ignore la position actuelle du pion */
+            if(i == 0 && j == 0) continue;
+            
+            /* Calcule les nouvelles coordonnées potentielles */
+            newX = pos.x + i;
+            newY = pos.y + j;
+            
+            /* Vérifie si la nouvelle position est :
+               1. Dans les limites de la grille (>= 0 et < tailleGrille)
+               2. Sur une case vide (== 0) */
+            if(newX >= 0 && newX < etatJeu.tailleGrille && 
+               newY >= 0 && newY < etatJeu.tailleGrille && 
+               etatJeu.grille[newY][newX] == 0) {
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+/* Fonction qui affiche la grille de jeu */
+void dessinerGrille(struct EtatJeu etatJeu) {
+    int i, j;
+    int largeurFenetre = 800;
+    int hauteurFenetre = 600;
+    int marge = 50;
+    int tailleCase;
+    int startX, startY;
+    char message[100];
+    
+    EffacerEcran(CouleurParNom("white"));
+    ChoisirCouleurDessin(CouleurParNom("black"));
+    
+    /* Affiche le message en fonction de la phase du jeu */
+    if(etatJeu.phase == 0) {
+        sprintf(message, "Joueur %d : Placez votre pion", etatJeu.tourJoueur);
+    } else if(etatJeu.phase == 1) {
+        sprintf(message, "Joueur %d : Deplacez votre pion", etatJeu.tourJoueur);
+    } else {
+        sprintf(message, "Joueur %d : Bloquez une case", etatJeu.tourJoueur);
+    }
+    EcrireTexte(200, 30, message, 2);
+    
+    /* Calcule la taille de chaque case de la grille */
+    tailleCase = (largeurFenetre - 2 * marge) / etatJeu.tailleGrille;
+    if (tailleCase * etatJeu.tailleGrille > (hauteurFenetre - 2 * marge)) {
+        tailleCase = (hauteurFenetre - 2 * marge) / etatJeu.tailleGrille;
+    }
+    /* Calcule la position de départ de la grille */
+    startX = (largeurFenetre - (tailleCase * etatJeu.tailleGrille)) / 2;
+    startY = (hauteurFenetre - (tailleCase * etatJeu.tailleGrille)) / 2;
+    
+    /* Pour chaque case de la grille */
+    for (i = 0; i < etatJeu.tailleGrille; i++) {
+        for (j = 0; j < etatJeu.tailleGrille; j++) {
+            int x = startX + (j * tailleCase);
+            int y = startY + (i * tailleCase);
+            
+            ChoisirCouleurDessin(CouleurParNom("black"));
+            DessinerRectangle(x, y, tailleCase, tailleCase);
+            
+            if (etatJeu.grille[i][j] == 1) {
+                ChoisirCouleurDessin(CouleurParNom("blue"));
+                RemplirRectangle(x + 5, y + 5, tailleCase - 10, tailleCase - 10);
+            } else if (etatJeu.grille[i][j] == 2) {
+                ChoisirCouleurDessin(CouleurParNom("red"));
+                RemplirRectangle(x + 5, y + 5, tailleCase - 10, tailleCase - 10);
+            } else if (etatJeu.grille[i][j] == 3) {
+                ChoisirCouleurDessin(CouleurParNom("black"));
+                RemplirRectangle(x + 5, y + 5, tailleCase - 10, tailleCase - 10);
+            }
+        }
+    }
+}
+
+/* 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 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;
+    }
+    
+    if (!peutDeplacer(etatJeu, etatJeu.tourJoueur)) {
+        return etatJeu.tourJoueur == 1 ? 2 : 1;
+    }
+    
+    return 0;
+}

src/jeu_humain.c

@@ -0,0 +1,136 @@
+#define _DEFAULT_SOURCE /* Pour utiliser _X et _Y */
+#include <stdio.h> /* Pour utiliser printf */
+#include <stdlib.h> /* Pour utiliser malloc() */
+#include <graph.h> /* Pour utiliser les fonctions graphiques */
+#include <unistd.h> /* Pour utiliser usleep */    
+#include "jeu.h" /* Pour utiliser les structures et les fonctions du jeu */
+#include "jeu_humain.h" /* Pour utiliser les fonctions de jeu_humain */
+
+void jouerModeHumain(struct EtatJeu *etatJeu) {
+    while (1) {
+        if (SourisCliquee()) {
+            if (etatJeu->phase == 0) {
+                gererPlacementInitial(etatJeu);
+            } else {
+                gererTourJoueur(etatJeu);
+            }
+            
+            if (etatJeu->phase > 0 && !peutDeplacer(*etatJeu, etatJeu->tourJoueur)) {
+                afficherVictoire(etatJeu->tourJoueur == 1 ? 2 : 1);
+                while (!SourisCliquee()) {
+                    usleep(100000);
+                }
+                break;
+            }
+        }
+        usleep(100000);
+    }
+}
+
+void gererPlacementInitial(struct EtatJeu *etatJeu) {
+    int x, y, i, j;
+    int largeurFenetre = 800;
+    int hauteurFenetre = 600;
+    int marge = 50;
+    int tailleCase;
+    int startX, startY;
+    
+    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;
+    
+    if (i >= 0 && i < etatJeu->tailleGrille && 
+        j >= 0 && j < etatJeu->tailleGrille && 
+        etatJeu->grille[i][j] == 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;
+        }
+        
+        if (etatJeu->tourJoueur == 2) {
+            etatJeu->phase = 1;
+            etatJeu->tourJoueur = 1;
+        } else {
+            etatJeu->tourJoueur = 2;
+        }
+        
+        dessinerGrille(*etatJeu);
+    }
+}
+
+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);
+            }
+        }
+    }
+}

src/jeu_ia.c

@@ -0,0 +1,205 @@
+#define _DEFAULT_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <graph.h>
+#include <unistd.h>
+#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()) {
+                if (etatJeu->phase == 0) {
+                    gererPlacementInitialIA(etatJeu);
+                } else {
+                    gererTourJoueurIA(etatJeu);
+                }
+            }
+        } else {
+            usleep(500000);
+            if (etatJeu->phase == 0) {
+                placementIA(etatJeu);
+            } else if (etatJeu->phase == 1) {
+                deplacementIA(etatJeu);
+            } else {
+                blocageIA(etatJeu);
+            }
+        }
+        
+        /* Vérifie si le joueur a gagné la partie */
+        if (etatJeu->phase > 0) {
+            gagnant = verifierVictoire(*etatJeu);
+            if (gagnant != 0) {
+                afficherVictoire(gagnant);
+                while (!SourisCliquee()) {
+                    usleep(500000);
+                }
+                break;
+            }
+        }
+        usleep(500000);
+    }
+}
+
+/* Fonction qui gère le placement initial de l'IA */
+void gererPlacementInitialIA(struct EtatJeu *etatJeu) {
+    int x, y, i, j;
+    int largeurFenetre = 800;
+    int hauteurFenetre = 600;
+    int marge = 50;
+    int tailleCase;
+    int startX, startY;
+    
+    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;
+    
+    x -= startX;
+    y -= startY;
+    
+    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) {
+        
+        etatJeu->grille[i][j] = 1;
+        etatJeu->joueur1.x = j;
+        etatJeu->joueur1.y = i;
+        etatJeu->tourJoueur = 2;
+        dessinerGrille(*etatJeu);
+    }
+}
+
+/* Fonction qui gère le tour de l'IA */
+void gererTourJoueurIA(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;
+    
+    /* 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;
+    
+    x -= startX;
+    y -= startY;
+    
+    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)) {
+                etatJeu->grille[etatJeu->joueur1.y][etatJeu->joueur1.x] = 0;
+                etatJeu->grille[i][j] = 1;
+                etatJeu->joueur1.x = j;
+                etatJeu->joueur1.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 = 2;
+                dessinerGrille(*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;
+    } while (etatJeu->grille[i][j] != 0);
+    
+    etatJeu->grille[i][j] = 2;
+    etatJeu->joueur2.x = j;
+    etatJeu->joueur2.y = i;
+    etatJeu->phase = 1;
+    etatJeu->tourJoueur = 1;
+    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;
+            
+            newX = etatJeu->joueur2.x + dx;
+            newY = etatJeu->joueur2.y + dy;
+            
+            if(newX >= 0 && newX < etatJeu->tailleGrille && 
+               newY >= 0 && newY < etatJeu->tailleGrille && 
+               etatJeu->grille[newY][newX] == 0) {
+                
+                etatJeu->grille[etatJeu->joueur2.y][etatJeu->joueur2.x] = 0;
+                etatJeu->grille[newY][newX] = 2;
+                etatJeu->joueur2.x = newX;
+                etatJeu->joueur2.y = newY;
+                etatJeu->phase = 2;
+                trouve = 1;
+            }
+        }
+    }
+    dessinerGrille(*etatJeu);
+}
+
+/* Fonction qui permet à l'IA de placer un pion de blocage */
+void blocageIA(struct EtatJeu *etatJeu) {
+    int i, j;
+    
+    do {
+        i = rand() % etatJeu->tailleGrille;
+        j = rand() % etatJeu->tailleGrille;
+    } while (etatJeu->grille[i][j] != 0);
+    
+    etatJeu->grille[i][j] = 3;
+    etatJeu->phase = 1;
+    etatJeu->tourJoueur = 1;
+    dessinerGrille(*etatJeu);
+}

src/main.c

@@ -0,0 +1,96 @@
+#define _DEFAULT_SOURCE /* Pour utiliser X et Y */
+#include <stdio.h>
+#include <stdlib.h>
+#include <graph.h>
+#include <unistd.h>
+#include <time.h>
+#include "jeu.h"
+#include "jeu_humain.h"
+#include "jeu_ia.h"
+
+/* fonction qui gère tout le menu du jeu avec les boutons et tout */
+void menuPrincipale() {
+    int tailleGrille = 3;
+    int continuer = 1;
+    char tailleStr[4];
+    int besoinRedessiner = 1;
+    struct EtatJeu etatJeu;
+
+    InitialiserGraphique(); /* Initialise la fenêtre graphique  */
+    CreerFenetre(100, 100, 800, 600); /* Crée la fenêtre graphique */
+    ChoisirTitreFenetre("Blokus"); /* Change le titre de la fenêtre */
+    
+    while (continuer) {
+        if (besoinRedessiner) { 
+            EffacerEcran(CouleurParNom("white"));
+            ChoisirCouleurDessin(CouleurParNom("black"));
+            EcrireTexte(290, 50, "Jeu du Blokus", 2);
+            EcrireTexte(250, 130, "Taille de la grille:", 1); 
+            sprintf(tailleStr, "%d", tailleGrille);
+            EcrireTexte(450, 130, tailleStr, 1); 
+            RemplirRectangle(500, 110, 30, 30); 
+            RemplirRectangle(540, 110, 30, 30); 
+            ChoisirCouleurDessin(CouleurParNom("white"));
+            EcrireTexte(510, 125, "+", 1); 
+            EcrireTexte(550, 125, "-", 1); 
+            ChoisirCouleurDessin(CouleurParNom("black"));
+            RemplirRectangle(250, 190, 300, 50); 
+            RemplirRectangle(250, 260, 300, 50); 
+            ChoisirCouleurDessin(CouleurParNom("white"));
+            EcrireTexte(280, 215, "1 Joueur (contre IA)", 1); 
+            EcrireTexte(280, 285, "2 Joueurs", 1); 
+            ChoisirCouleurDessin(CouleurParNom("black"));
+            RemplirRectangle(250, 330, 300, 50); 
+            ChoisirCouleurDessin(CouleurParNom("white"));
+            EcrireTexte(280, 355, "Quitter", 1); 
+            
+            besoinRedessiner = 0;
+        }
+
+        if (SourisCliquee()) { /* Si la souris est cliquée */
+            int mouseX = _X;
+            int mouseY = _Y;
+
+            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) { /* Si la souris est sur la case - */
+                if (tailleGrille > 3) {
+                    tailleGrille--;
+                    besoinRedessiner = 1;
+                }
+            } else if (mouseX >= 250 && mouseX <= 600) { /* Si la souris est sur la case 1 Joueur (contre IA) */
+                if ((mouseY >= 180 && mouseY <= 230) || (mouseY >= 250 && mouseY <= 300)) {
+                    /* calcule le mode de jeu en fonction de où on clique (1 pour ia, 2 pour 2 joueurs) */
+                    int mode = (mouseY >= 180 && mouseY <= 230) ? 1 : 2;
+                    etatJeu = initialiserJeu(tailleGrille, mode);
+                    EffacerEcran(CouleurParNom("white"));
+                    dessinerGrille(etatJeu);
+                    
+                    if (mode == 1) {
+                        jouerModeIA(&etatJeu);
+                    } else {
+                        jouerModeHumain(&etatJeu);
+                    }
+                    
+                    besoinRedessiner = 1;
+                    
+                } else if (mouseY >= 320 && mouseY <= 370) {
+                    continuer = 0;
+                }
+            }
+        }
+        usleep(10000);
+    }
+    
+    FermerGraphique();
+}
+
+/* fonction principale qui lance le jeu */
+int main() {
+    srand(time(NULL)); /* initialise le générateur de nombres aléatoires */
+    menuPrincipale();
+    return 0;
+}