Dernière étape avant le rapport + IA a régler

jeu.c

@@ -0,0 +1,181 @@
+#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) {
+    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 0;
+    }
+
+    
+    if (!peutDeplacer(etatJeu, etatJeu.tourJoueur)) {
+        return etatJeu.tourJoueur == 1 ? 2 : 1;
+            return 2;
+        } 
+    return EXIT_FAILURE;
+}

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 */

jeu_humain.c

@@ -0,0 +1,146 @@
+#include <stdio.h> 
+#include <stdlib.h> 
+#include <graph.h> 
+#include <time.h> 
+#include "jeu.h" 
+#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);
+            }
+        }
+    }
+}
+
+

jeu_humain.h

@@ -0,0 +1,16 @@
+#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

jeu_ia.c

@@ -0,0 +1,204 @@
+#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 {
+            sleep(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()) {
+                    sleep(500000);
+                }
+                break;
+            }
+        }
+        sleep(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);
+}

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 */

main.c

@@ -0,0 +1,95 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <graph.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();
+    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;
+}

makefile

@@ -2,51 +2,30 @@
 CC = gcc
 
 # options de compilation
-CFLAGS = -ansi -pedantic -Wall -Wextra
+CFLAGS = -Wall -ansi -pedantic -g -lgraph
-LDFLAGS = -lgraph
 
 # nom de l'exécutable
 NAME = blocus
 
-# dossiers
-SRC_DIR = src
-INC_DIR = include
-OBJ_DIR = obj
-
 # sources
-SRCS = $(SRC_DIR)/main.c \
+SRCS = main.c jeu.c jeu_humain.c jeu_ia.c
-       $(SRC_DIR)/jeu.c \
-       $(SRC_DIR)/jeu_humain.c \
-       $(SRC_DIR)/jeu_ia.c
 
-# objets
-OBJS = $(SRCS:$(SRC_DIR)/%.c=$(OBJ_DIR)/%.o)
 
-# headers
-INCS = -I$(INC_DIR)
 
 # règle par défaut
-all: $(OBJ_DIR) $(NAME)
+all: $(NAME)
-
-# création du dossier obj s'il n'existe pas
-$(OBJ_DIR):
-	mkdir -p $(OBJ_DIR)
 
 # création de l'exécutable
-$(NAME): $(OBJS)
+$(NAME): $(SRCS)
-	$(CC) $(OBJS) -o $(NAME) $(LDFLAGS)
+	$(CC) $(CFLAGS) $^ -o $@
 
-# compilation des fichiers sources
-$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c
-	$(CC) $(CFLAGS) $(INCS) -c $< -o $@
 
-# nettoyage des fichiers objets
+# nettoyage des fichiers générés
 clean:
-	rm -rf $(OBJ_DIR)
 	rm -f $(NAME)
 
 # exécution du programme
 run: all
 	./$(NAME)
 
-.PHONY: all clean fclean re run
+.PHONY: all clean run