diff --git a/include/jeu.h b/include/jeu.h
deleted file mode 100644
index daff224..0000000
--- a/include/jeu.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#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 */
diff --git a/include/jeu_humain.h b/include/jeu_humain.h
deleted file mode 100644
index b1554a5..0000000
--- a/include/jeu_humain.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#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);
-
-void attendre(int secondes);
-#endif
diff --git a/include/jeu_ia.h b/include/jeu_ia.h
deleted file mode 100644
index cf006a6..0000000
--- a/include/jeu_ia.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#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 */
diff --git a/src/jeu.c b/src/jeu.c
deleted file mode 100755
index abc4935..0000000
--- a/src/jeu.c
+++ /dev/null
@@ -1,181 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <graph.h>
-#include "../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) {
-    int continuer = 1;
-    char message[100];
-    int mouseX, mouseY;
-    int xStartNouveau = 200, yStartNouveau = 400, largeur = 200, hauteur = 50;
-    int xStartQuitter = 400, yStartQuitter = 400;
-
-    EffacerEcran(CouleurParNom("white"));
-    ChoisirCouleurDessin(CouleurParNom("black"));
-    
-    sprintf(message, "Le joueur %d remporte la partie !", gagnant);
-    EcrireTexte(250, 300, message, 2);
-    
-    EcrireTexte(100,500, "Cliquez sur 'New Party' pour recommencer ou 'Quitter' pour quitter.", 1);
-
-    ChoisirCouleurDessin(CouleurParNom("blue"));
-    RemplirRectangle(xStartNouveau, yStartNouveau, largeur, hauteur);
-    ChoisirCouleurDessin(CouleurParNom("white"));
-    EcrireTexte(xStartNouveau + 5, yStartNouveau + 30, "New Party", 2);
-
-    ChoisirCouleurDessin(CouleurParNom("red"));
-    RemplirRectangle(xStartQuitter, yStartQuitter, largeur, hauteur);
-    ChoisirCouleurDessin(CouleurParNom("white"));
-    EcrireTexte(xStartQuitter + 90, yStartQuitter + 30, "Quitter", 2);
-
-    while (continuer) {
-        if (SourisCliquee()) {
-            mouseX = _X;
-            mouseY = _Y;
-            
-            if (mouseX >= xStartNouveau && mouseX <= xStartNouveau + largeur && mouseY >= yStartNouveau && mouseY <= yStartNouveau + hauteur) {
-                continuer = 0;
-                return;
-            }
-            
-            if (mouseX >= xStartQuitter && mouseX <= xStartQuitter + largeur && mouseY >= yStartQuitter && mouseY <= yStartQuitter + hauteur) {
-                continuer = 0;
-                exit(EXIT_SUCCESS);
-            }
-        }
-    }
-}
-
-/* Fonction qui vérifie si le joueur a gagné la partie */
-int verifierVictoire(struct EtatJeu etatJeu) {
-    if (etatJeu.phase == 0) {
-        return EXIT_FAILURE;
-    }
-
-    
-    if (!peutDeplacer(etatJeu, etatJeu.tourJoueur)) {
-        return etatJeu.tourJoueur == 1 ? 2 : 1;
-            return 2;
-        } 
-    return EXIT_FAILURE;
-}
\ No newline at end of file
diff --git a/src/jeu_humain.c b/src/jeu_humain.c
deleted file mode 100644
index 20fea3b..0000000
--- a/src/jeu_humain.c
+++ /dev/null
@@ -1,146 +0,0 @@
-#include <stdio.h> 
-#include <stdlib.h> 
-#include <graph.h> 
-#include <time.h> 
-#include "../include/jeu.h" 
-#include "../include/jeu_humain.h" 
-
-
-void attendre(int secondes) {
-    time_t start_time = time(NULL);
-
-        while(difftime(time(NULL), start_time) < secondes) {
-            break;
-        }
-    }
-
-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()) {
-                    attendre(1); 
-                }
-                break;
-            }
-        }
-        attendre(1);  
-    }
-}
-
-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);
-            }
-        }
-    }
-}
-
-
diff --git a/src/jeu_ia.c b/src/jeu_ia.c
deleted file mode 100644
index f3d9f36..0000000
--- a/src/jeu_ia.c
+++ /dev/null
@@ -1,205 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <graph.h>
-#include <time.h>
-#include "../include/jeu.h"
-#include "../include/jeu_ia.h"
-#include "../include/jeu_humain.h" /* Pour utiliser la fonction attendre */
-
-/* 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 {
-            attendre(1);
-            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()) {
-                    attendre(1);
-                }
-                break;
-            }
-        }
-        attendre(1);
-    }
-}
-
-/* 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);
-}
\ No newline at end of file
diff --git a/src/main.c b/src/main.c
deleted file mode 100644
index 1656f35..0000000
--- a/src/main.c
+++ /dev/null
@@ -1,95 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <graph.h>
-#include <time.h>
-#include "../include/jeu.h"
-#include "../include/jeu_humain.h"
-#include "../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();
-    CreerFenetre(100, 100, 800, 600);
-    ChoisirTitreFenetre("Blocus");   
-
-
-    while (continuer) {
-        if (besoinRedessiner) { 
-            EffacerEcran(CouleurParNom("white"));
-            ChoisirCouleurDessin(CouleurParNom("black"));
-            EcrireTexte(290, 50, "Jeu du Blocus", 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()) { 
-            int mouseX = _X;
-            int mouseY = _Y;
-
-            if (mouseX >= 500 && mouseX <= 530 && mouseY >= 110 && mouseY <= 140) {
-                if (tailleGrille < 9) {
-                    tailleGrille++;
-                    besoinRedessiner = 1;
-                }
-               }  else if (mouseX >= 540 && mouseX <= 570 && mouseY >= 110 && mouseY <= 140) { 
-                if (tailleGrille > 3) {
-                    tailleGrille--;
-                    besoinRedessiner = 1;
-                }
-            } else if (mouseX >= 250 && mouseX <= 600) { 
-                if ((mouseY >= 180 && mouseY <= 230) || (mouseY >= 250 && mouseY <= 300)) {
-              
-                    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;
-                }
-            }
-        }
-        attendre(10);
-    }
-    
-    FermerGraphique();
-}
-
-
-int main(void) {
-    srand((unsigned int)time(NULL));
-    menuPrincipale();
-    return EXIT_FAILURE;
-}