denier git merci pour le projet

.#Makefile

@@ -1 +0,0 @@
-khadir@salle222-07.122283:1731070080

Makefile

@@ -6,44 +6,36 @@ but : game
 
 OFILES = taille.o \
          menu.o \
-	 grille.o \
 	 nbjoueur.o \
-	 nbjoueur2.o \
-	 boutonJVJ.o \
-	 jeu.o \
+	 comportementJCJ.o \
+	 comportementJCIA.o \
+	 definirMaxXY.o \
+	 initialisation.o \
+	 coordoner.o \
          main.o
 
 
-#deplacement.o, pion.o, obstacle.o
-
-
 CC = gcc
 
 CFLAGS = -Wall -ansi -pedantic
 
 # CHAPITRE 3 : DEPENDANCES (REGLES IMPLICITES)
 
-#deplacement.o : pion.h obstacle.h
+menu.o : taille.h menu.h nbjoueur.h
 
-menu.o : taille.h menu.h nbjoueur.h nbjoueur2.h boutonJVJ.h
+taille.o : taille.h
 
-#pion.o : deplacement.h obstacle.h
+coordoner.o : coordoner.h initialisation.h
 
-taille.o : taille.h jeu.h
+initialisation.o : initialisation.h
 
 nbjoueur.o : nbjoueur.h
 
-boutonJVJ.o : boutonJVJ.h
+comportementJCJ.o : comportementJCJ.h definirMaxXY.h initialisation.h coordoner.h
 
-nbjoueur2.o : nbjoueur2.h
+comportementJCIA.o : comportementJCIA.h definirMaxXY.h initialisation.h coordoner.h 
 
-grille.o : grille.h taille.h
-
-#obstacle.o : pion.h
-
-jeu.o : jeu.h
-
-main.o : menu.h jeu.h
+main.o : menu.h comportementJCJ.h comportementJCIA.h
 
 
 # CHAPITRE 4 : DEPENDANCES AVEC COMMANDES

README.md

@@ -1,52 +0,0 @@
-Dans le code actuel il faut absolument 1 écran 
-
-    un où l'on peut choisir la taille de la grille
-    puis on choisi si il y a un second joueur
-
-Un écran où
-
-    un ou l'on peut jouer au jeu
-
-
-
-    et un où l'on a le gagnant et de choisir entre terminer le programme et commancer une nouvelle partie
-
-dans une partie a un joueur il faudra implémenter un bot pour faire le J2
-
-
-il faut bien diviser le projet en différent fichier pas plus de une fonction par fichier si possible (VRAIMENT IL FAUT LE FAIRE)
-
-
-
-Voici un exemple de tableau pour la grille comme elle est a double entrer donc par exemple si le joueur demande une taille de plateu de 3 ca donnera
-
-
-    11111
-    10001
-    10001
-    10001
-    11111
-
-
-car on prend en compte les bordure pour la detection des blocs par rapport au joueur
-
-si il aurais pris 9:
-
-
-    11111111111
-    10000000001
-    10000000001
-    10000000001
-    10000000001
-    10000000001
-    10000000001
-    10000000001
-    10000000001
-    10000000001
-    11111111111
-
-
-On fait taille du tableau +2 pour prendre en compte la bordure
-
-
-création des fichier nbjoueur pour faire des boutton clicable pour sélectionner le nombre de joueur

boutonJVJ.c

@@ -1,23 +0,0 @@
-#include <graph.h>
-#include <stdio.h>
-
-/* Fonction qui permet de délimiter le clique de la souris pour le bouton de Joueur contre Joueur */
-
-int boutonJVJ(){
-	int choix = 0, SourisX = 0, SourisY = 0;
-	while(choix == 0){
-		if (SourisCliquee()){
-			SourisX = _X;
-			SourisY = _Y;
-		}
-		if(SourisX > 100 && SourisX < 250 && SourisY > 150 && SourisY < 200){
-			choix = 1;
-			printf("Choix du JCJ\n");
-		}else if(SourisX > 400 && SourisX < 550 && SourisY > 150 && SourisY < 200){
-			choix = 2;
-			printf("Choix du JCIA\n");
-		}
-	}
-	return choix;
-}
-

boutonJVJ.h

@@ -1,7 +0,0 @@
-#ifndef BOUTONJVJ_H
-#define BOUTONJVIA_H
-
-
-int boutonJVJ();
-
-#endif

comportementJCIA.c

@@ -0,0 +1,205 @@
+#include <graph.h>
+#include <time.h>
+
+
+#include "definirMaxXY.h"
+#include "initialisation.h"
+#include "coordoner.h"
+
+
+int compJCIA(int taille){
+	int fin = 0, tabx = 0, taby = 0, tour = 0, initi = 0, SourisX = 0, SourisY = 0, initialiser = 0;
+	int maxX = 0, maxY = 0, joueurx1 = 0, joueury1 = 0, joueurx2 = 0, joueury2 = 0, placer = 1;
+        int emplacementcooX1 = 0, emplacementcooX2 = 0, emplacementcooY1 = 0, emplacementcooY2 = 0;
+	int grille[taille+2][taille+2];
+	int empblock[4] = {0, 0, 0, 0}, empperso[4] = {0, 0, 0, 0};
+	srand(time(NULL));
+	maxX = DefMaxX(taille);		/* Définie les positions maximum de la grille */
+	maxY = DefMaxY(taille);
+	for(tabx = 0; tabx < taille + 2; tabx++){
+		for(taby = 0; taby < taille + 2; taby++){
+			grille[tabx][taby] = 0;					/* Initialise le tableau a double dimension */
+			if(taby == 0 || taby == taille + 1 || tabx == 0 || tabx == taille + 1){
+				grille[tabx][taby] = 9;
+			}
+		}
+	}
+	EcrireTexte(30, 40, "Joueur 1 choisissez l'emplacement de base du pion 1", 1);
+	while(initi == 0){				/* Initialise l'emplacement du joueur 1 */
+		if(SourisCliquee()){
+			SourisX = _X;
+			SourisY = _Y;
+		}
+		if(initialiser == 0){
+			if(SourisX >= 50 && SourisX <= maxX && SourisY >= 100 && SourisY <= maxY){
+				/* Change a l'index du tableau une valeur pour colision et affiche le sprote sur la case correspondante */
+				ChargerSprite("./image/pion1.png");
+				joueurx1 = initialisationX(SourisX, maxX, taille);	/* renvoie l'index de la case cliquee */
+				joueury1 = initialisationY(SourisY, maxY, taille);
+				emplacementcooX1 = coordonerX(SourisX);		/* renvoie les coordoner qui a été cliquee dans la grille */
+				emplacementcooY1 = coordonerY(SourisY);
+				AfficherSprite(1, emplacementcooX1, emplacementcooY1);
+				grille[joueury1][joueurx1] = 1;		/* Permet de changer a l'index cliquee la valeur pour la detection de colision */
+				initialiser++;
+				SourisX = 0;
+				SourisY = 0;
+				EffaceIA();		/* Clear l'affichage du haut */
+				EcrireTexte(30, 40, "Joueur 2 choisissez l'emplacement de base du pion 2", 1);
+			}
+		}else if (initialiser == 1){
+			/* Change a l'index du tableau une valeur pour colision et affiche le sprite sur la case correspondante */
+			SourisX = rand() % maxX;
+			SourisY = rand() % maxY;	/* Voici l'IA */
+			if(SourisX >= 50 && SourisX <= maxX && SourisY >= 100 && SourisY <= maxY){
+				ChargerSprite("./image/pion2.png");
+				joueurx2 = initialisationX(SourisX, maxX, taille);	/* renvoi l'index de la case de la grille choisie pa l'IA */
+				joueury2 = initialisationY(SourisY, maxY, taille);
+				if(grille[joueury2][joueurx2] != 1){
+					emplacementcooX2 = coordonerX(SourisX);		/* renvoie les coordonées de l'emplacement choisie par l'IA */
+					emplacementcooY2 = coordonerY(SourisY);
+					AfficherSprite(2, emplacementcooX2, emplacementcooY2);
+					grille[joueury2][joueurx2] = 2;			/* change a l'index la valeur pour la colision */
+					initialiser++;
+					initi++;
+				}
+				SourisX = 0;
+				SourisY = 0;
+			}
+		}
+	}
+	ChargerSprite("./image/croix1.png");	/* charge les images des blocks */
+	ChargerSprite("./image/croix2.png");
+	while(fin == 0){
+		if(tour == 0){
+			EffaceIA();	/* efface l'affichage des tours */
+			EcrireTexte(30, 40, "Tour du joueur 1", 2);
+			SourisX = 0;
+			SourisY = 0;
+			while(placer == 1){
+				if(SourisCliquee()){
+					SourisX = _X;
+					SourisY = _Y;
+				}
+				VerifBlock1(SourisX, SourisY, maxX, maxY, taille, empperso);
+				if(grille[joueury1+1][joueurx1-1] != 0 && grille[joueury1+1][joueurx1] != 0 && grille[joueury1+1][joueurx1+1] && grille[joueury1][joueurx1-1] != 0 && grille[joueury1][joueurx1+1] != 0 && grille[joueury1-1][joueurx1-1] != 0 && grille[joueury1-1][joueurx1] != 0 && grille[joueury1-1][joueurx1+1] != 0){
+					LibererSprite(1);
+					LibererSprite(2);	/* verification des conditions de victoire */
+					LibererSprite(3);
+					LibererSprite(4);
+					return 3;		/* arrete le programme et indique qui a gagner (le 3 car c'est contre l'IA) */
+				}
+				if(empperso[0] != 0){
+					if(grille[empperso[1]][empperso[0]] == 0 && (empperso[1] <= joueury1+1 && empperso[1] >= joueury1-1) && (empperso[0] <= joueurx1+1 && empperso[0] >= joueurx1-1)){
+						grille[joueury1][joueurx1] = 0;		/* Change l'emplacement précedent pour le rendre disponible */
+						ChoisirCouleurDessin(CouleurParNom("white"));
+						RemplirRectangle(emplacementcooX1, emplacementcooY1, 40, 40);	/* Efface le spite a l'ancien emplacement */
+						ChoisirCouleurDessin(CouleurParNom("black"));
+						joueurx1 = empperso[0];		/* donne l'index de la grille par rapport au clique effectuer */
+						joueury1 = empperso[1];
+						empperso[2] = coordonerX(SourisX);	/* donne les coordonnés du clique sur la grille */
+						empperso[3] = coordonerY(SourisY);
+						grille[empperso[1]][empperso[0]] = 1;	/* change la valeur pour la colision */
+						AfficherSprite(1, empperso[2], empperso[3]);	/* Affiche le sprite a l'emplacement demander */
+						emplacementcooX1 = empperso[2];
+						emplacementcooY1 = empperso[3];		/* Recupère l'ancient index pour le supprimer plus tard */
+						placer = 0;
+					}
+				}
+			}
+			empperso[0] = 0;	/* change empperso[0] a 0 pour la confirmation que le joueur a bien changer une variable */
+			placer = 1;
+			tour++;
+		}else if(tour == 1){
+			EffaceIA();		/* Efface l'ancient emplacement du haut de l'affichage */
+			EcrireTexte(30, 40, "Joueur 1 place le bloc", 2);
+			SourisX = 0;		/* Réinitialise les variables des souris pour refaire une SourisCliquee() */
+			SourisY = 0;
+			while(placer == 1){
+				if(SourisCliquee()){
+					SourisX = _X;
+					SourisY = _Y;
+				}		/* Prend les coordoner de la souris cliquee */
+				VerifBlock1(SourisX, SourisY, maxX, maxY, taille, empblock);
+				if(empblock[0] != 0){
+					if(grille[empblock[1]][empblock[0]] == 0){
+						empblock[2] = coordonerX(SourisX);	/* Fait en sorte d'avoir les coordonnées par rapport a la grille */
+						empblock[3] = coordonerY(SourisY);
+						grille[empblock[1]][empblock[0]] = 3;	/* change l'index de colision */
+						AfficherSprite(3, empblock[2], empblock[3]);	/* Affiche le sprite */
+						placer = 0;
+					}
+				}
+			}
+			empblock[0] = 0;	/* change empperso[0] a 0 pour la confirmation que le joueur a bien changer une variable */
+			placer = 1;
+			tour++;
+		}else if(tour == 2){
+			EffaceIA();		/* Efface l'affichage du haut de l'écran */
+                        EcrireTexte(30, 40, "Tour du joueur 2", 2);
+                        SourisX = 0;		/* remet a zero les variable Souris */
+                        SourisY = 0;
+                        while(placer == 1){
+                                SourisX = rand() % maxX;	/* Le code de l'IA pour l'IA */
+                                SourisY = rand() % maxY;
+                                VerifBlock1(SourisX, SourisY, maxX, maxY, taille, empperso);
+				if(grille[joueury2+1][joueurx2-1] != 0 && grille[joueury2+1][joueurx2] != 0 && grille[joueury2+1][joueurx2+1] != 0 && grille[joueury2][joueurx2-1] != 0 && grille[joueury2][joueurx2+1] != 0 && grille[joueury2-1][joueurx2-1] != 0 && grille[joueury2-1][joueurx2] != 0 && grille[joueury2-1][joueurx2+1] != 0){
+					LibererSprite(1);
+					LibererSprite(2);
+					LibererSprite(3);	/* condition de perte pour l'IA */
+					LibererSprite(4);
+					return 1;		/* retourne 1 pour dire que le joueur 1 a gagner */
+				}
+                                if(empperso[0] != 0){
+                                        if(grille[empperso[1]][empperso[0]] == 0 && (empperso[1] <= joueury2+1 && empperso[1] >= joueury2-1) && (empperso[0] <= joueurx2+1 && empperso[0] >= joueurx2-1)){
+                                                grille[joueury2][joueurx2] = 0;		/* met a l'index précedent a zero */
+                                                ChoisirCouleurDessin(CouleurParNom("white"));
+                                                RemplirRectangle(emplacementcooX2, emplacementcooY2, 40, 40);	/* supprime le sprite de l'emplacement précedant */
+                                                ChoisirCouleurDessin(CouleurParNom("black"));
+                                                joueurx2 = empperso[0];			/* Change les anciennes donner par les nouvelles donner */
+                                                joueury2 = empperso[1];
+                                                empperso[2] = coordonerX(SourisX);	/* Donne les coordoner par rapport au coordoner donner par la souris et la grille */
+                                                empperso[3] = coordonerY(SourisY);
+                                                grille[empperso[1]][empperso[0]] = 2;	/* Change l'emplacement de la grille pour la colision */
+                                                AfficherSprite(2, empperso[2], empperso[3]);
+                                                emplacementcooX2 = empperso[2];		/* met le nouvelle emplacement dans l'ancien */
+                                                emplacementcooY2 = empperso[3];
+                                                placer = 0;
+                                        }
+                                }
+                        }
+                        empperso[0] = 0;
+                        placer = 1;
+                        tour++;
+
+		}else if(tour == 3){
+			EffaceIA();
+			EcrireTexte(30, 40, "Joueur 2 place le bloc", 2);
+			SourisX = 0;
+			SourisY = 0;
+			while(placer == 1){
+				SourisX = rand() % maxX;		/* code de l'IA */
+				SourisY = rand() % maxY;
+				VerifBlock1(SourisX, SourisY, maxX, maxY, taille, empblock);
+				if(empblock[0] != 0){
+					if(grille[empblock[1]][empblock[0]] == 0){
+						empblock[2] = coordonerX(SourisX);	/* même chose que précedemment */
+						empblock[3] = coordonerY(SourisY);
+						grille[empblock[1]][empblock[0]] = 4;
+						AfficherSprite(4, empblock[2], empblock[3]);
+						placer = 0;
+					}
+				}
+			}
+			empblock[0] = 0;
+			placer = 1;
+			tour = 0;
+		}
+	}
+}
+
+
+void EffaceIA(){
+	ChoisirCouleurDessin(CouleurParNom("white"));
+	RemplirRectangle(0, 0, 650, 50);			/* Fonction qui supprime l'affichage des tours */
+	ChoisirCouleurDessin(CouleurParNom("black"));
+}

comportementJCIA.h

@@ -0,0 +1,9 @@
+#ifndef COMPORTEMENTJCIA_H
+#define COMPORTEMENTJCIA_H
+
+
+int compJCIA(int taille);
+
+void EffaceIA();
+
+#endif

comportementJCJ.c

@@ -0,0 +1,203 @@
+#include <graph.h>
+
+
+#include "definirMaxXY.h"
+#include "initialisation.h"
+#include "coordoner.h"
+
+
+int compJCJ(int taille){
+	int fin = 0, tabx = 0, taby = 0, tour = 0, initi = 0, SourisX = 0, SourisY = 0, initialiser = 0;
+	int maxX = 0, maxY = 0, joueurx1 = 0, joueury1 = 0, joueurx2 = 0, joueury2 = 0, placer = 1;
+        int emplacementcooX1 = 0, emplacementcooX2 = 0, emplacementcooY1 = 0, emplacementcooY2 = 0;
+	int grille[taille+2][taille+2];
+	int empblock[4] = {0, 0, 0, 0}, empperso[4] = {0, 0, 0, 0};
+	maxX = DefMaxX(taille);			/* Defini les maximum de X et Y */
+	maxY = DefMaxY(taille);
+	for(tabx = 0; tabx < taille + 2; tabx++){
+		for(taby = 0; taby < taille + 2; taby++){
+			grille[tabx][taby] = 0;		/* Defini la grille */
+			if(taby == 0 || taby == taille + 1 || tabx == 0 || tabx == taille + 1){
+				grille[tabx][taby] = 9;
+			}
+		}
+	}
+	EcrireTexte(30, 40, "Joueur 1 choisissez l'emplacement de base du pion 1", 1);
+	while(initi == 0){		/* Initialise la position des deux joueurs */
+		if(SourisCliquee()){	/* Recupère les coordonées de la souris */
+			SourisX = _X;
+			SourisY = _Y;
+		}
+		if(initialiser == 0){
+			if(SourisX >= 50 && SourisX <= maxX && SourisY >= 100 && SourisY <= maxY){
+				ChargerSprite("./image/pion1.png");	/* Charge l'image, trouve l'index par la position de la souris ainsi que les coordonées */
+				joueurx1 = initialisationX(SourisX, maxX, taille);
+				joueury1 = initialisationY(SourisY, maxY, taille);
+				emplacementcooX1 = coordonerX(SourisX);
+				emplacementcooY1 = coordonerY(SourisY);
+				AfficherSprite(1, emplacementcooX1, emplacementcooY1);	/* Affiche le sprite */
+				grille[joueury1][joueurx1] = 1;
+				initialiser++;
+				SourisX = 0;
+				SourisY = 0;
+				Efface();
+				EcrireTexte(30, 40, "Joueur 2 choisissez l'emplacement de base du pion 2", 1);
+			}
+		}else if (initialiser == 1){
+			if(SourisX >= 50 && SourisX <= maxX && SourisY >= 100 && SourisY <= maxY){
+				ChargerSprite("./image/pion2.png");
+				joueurx2 = initialisationX(SourisX, maxX, taille);
+				joueury2 = initialisationY(SourisY, maxY, taille);
+				if(grille[joueury2][joueurx2] != 1){		/* Si l'emplacement n'est pas déjà pris par l'user 1 */
+					emplacementcooX2 = coordonerX(SourisX);
+					emplacementcooY2 = coordonerY(SourisY);
+					AfficherSprite(2, emplacementcooX2, emplacementcooY2);
+					grille[joueury2][joueurx2] = 2;
+					initialiser++;
+					initi++;
+				}
+				SourisX = 0;
+				SourisY = 0;
+			}
+		}
+	}					/* Charge les sprites */
+	ChargerSprite("./image/croix1.png");
+	ChargerSprite("./image/croix2.png");
+	while(fin == 0){
+		if(tour == 0){		/* Tour du joueur 1 */
+			Efface();
+			EcrireTexte(30, 40, "Tour du joueur 1", 2);
+			SourisX = 0;
+			SourisY = 0;
+			while(placer == 1){
+				if(SourisCliquee()){
+					SourisX = _X;	/* Recupere les coordonnées de la souris X et Y */
+					SourisY = _Y;
+				}
+				VerifBlock1(SourisX, SourisY, maxX, maxY, taille, empperso);
+				if(grille[joueury1+1][joueurx1-1] != 0 && grille[joueury1+1][joueurx1] != 0 && grille[joueury1+1][joueurx1+1] != 0 && grille[joueury1][joueurx1-1] != 0 && grille[joueury1][joueurx1+1] != 0 && grille[joueury1-1][joueurx1-1] != 0 && grille[joueury1-1][joueurx1] != 0 && grille[joueury1-1][joueurx1+1] != 0){
+					LibererSprite(1);
+					LibererSprite(2);		/* condition de victoire */
+					LibererSprite(3);
+					LibererSprite(4);
+					return 2;
+				}
+				if(empperso[0] != 0){
+					if(grille[empperso[1]][empperso[0]] == 0 && (empperso[1] <= joueury1+1 && empperso[1] >= joueury1-1) && (empperso[0] <= joueurx1+1 && empperso[0] >= joueurx1-1)){
+						grille[joueury1][joueurx1] = 0;
+						ChoisirCouleurDessin(CouleurParNom("white"));
+						RemplirRectangle(emplacementcooX1, emplacementcooY1, 40, 40);	/* Suprime l'ancient perso pour le remplacer par un nouveau */
+						ChoisirCouleurDessin(CouleurParNom("black"));
+						joueurx1 = empperso[0];				/* Recupere les index du tableau par rapport au clique effectuer*/
+						joueury1 = empperso[1];
+						empperso[2] = coordonerX(SourisX);
+						empperso[3] = coordonerY(SourisY);		/* Recupere les coordoner pour les sprites */
+						grille[empperso[1]][empperso[0]] = 1;
+						AfficherSprite(1, empperso[2], empperso[3]);
+						emplacementcooX1 = empperso[2];			/* Sauvegarde les anciennes coordoner pour supressions de sprite */
+						emplacementcooY1 = empperso[3];
+						placer = 0;
+					}
+				}
+			}
+			empperso[0] = 0;
+			placer = 1;
+			tour++;
+		}else if(tour == 1){		/* Fonction qui place les blocs du joueur 1 */
+			Efface();
+			EcrireTexte(30, 40, "Joueur 1 place le bloc", 2);
+			SourisX = 0;
+			SourisY = 0;
+			while(placer == 1){
+				if(SourisCliquee()){
+					SourisX = _X;		/* Recupere les coordonnées de la souris */
+					SourisY = _Y;
+				}
+				VerifBlock1(SourisX, SourisY, maxX, maxY, taille, empblock);
+				if(empblock[0] != 0){
+					if(grille[empblock[1]][empblock[0]] == 0){
+						empblock[2] = coordonerX(SourisX);
+						empblock[3] = coordonerY(SourisY);		/* Récupere les coordonnées et index pour le placement de bloc */
+						grille[empblock[1]][empblock[0]] = 3;
+						AfficherSprite(3, empblock[2], empblock[3]);
+						placer = 0;
+					}
+				}
+			}
+			empblock[0] = 0;
+			placer = 1;
+			tour++;
+		}else if(tour == 2){		/* Tour du joueur 2 le code est le même que pour le joueur 1 mais avec des variables du joueur 2 */
+			Efface();
+                        EcrireTexte(30, 40, "Tour du joueur 2", 2);
+                        SourisX = 0;
+                        SourisY = 0;
+                        while(placer == 1){
+                                if(SourisCliquee()){
+                                        SourisX = _X;
+                                        SourisY = _Y;
+                                }
+                                VerifBlock1(SourisX, SourisY, maxX, maxY, taille, empperso);
+				if(grille[joueury2+1][joueurx2-1] != 0 && grille[joueury2+1][joueurx2] != 0 && grille[joueury2+1][joueurx2+1] != 0 && grille[joueury2][joueurx2-1] != 0 && grille[joueury2][joueurx2+1] != 0 && grille[joueury2-1][joueurx2-1] != 0 && grille[joueury2-1][joueurx2] != 0 && grille[joueury2-1][joueurx2+1]){
+					LibererSprite(1);
+					LibererSprite(2);
+					LibererSprite(3);
+					LibererSprite(4);
+					return 1;
+				}
+                                if(empperso[0] != 0){
+                                        if(grille[empperso[1]][empperso[0]] == 0 && (empperso[1] <= joueury2+1 && empperso[1] >= joueury2-1) && (empperso[0] <= joueurx2+1 && empperso[0] >= joueurx2-1)){
+                                                grille[joueury2][joueurx2] = 0;
+                                                ChoisirCouleurDessin(CouleurParNom("white"));
+                                                RemplirRectangle(emplacementcooX2, emplacementcooY2, 40, 40);
+                                                ChoisirCouleurDessin(CouleurParNom("black"));
+                                                joueurx2 = empperso[0];
+                                                joueury2 = empperso[1];
+                                                empperso[2] = coordonerX(SourisX);
+                                                empperso[3] = coordonerY(SourisY);
+                                                grille[empperso[1]][empperso[0]] = 2;
+                                                AfficherSprite(2, empperso[2], empperso[3]);
+                                                emplacementcooX2 = empperso[2];
+                                                emplacementcooY2 = empperso[3];
+                                                placer = 0;
+                                        }
+                                }
+                        }
+                        empperso[0] = 0;
+                        placer = 1;
+                        tour++;
+
+		}else if(tour == 3){	/* Place les blocs comme pour les blocs du joueur 2 */
+			Efface();
+			EcrireTexte(30, 40, "Joueur 2 place le bloc", 2);
+			SourisX = 0;
+			SourisY = 0;
+			while(placer == 1){
+				if(SourisCliquee()){
+					SourisX = _X;
+					SourisY = _Y;
+				}
+				VerifBlock1(SourisX, SourisY, maxX, maxY, taille, empblock);
+				if(empblock[0] != 0){
+					if(grille[empblock[1]][empblock[0]] == 0){
+						empblock[2] = coordonerX(SourisX);
+						empblock[3] = coordonerY(SourisY);
+						grille[empblock[1]][empblock[0]] = 4;
+						AfficherSprite(4, empblock[2], empblock[3]);
+						placer = 0;
+					}
+				}
+			}
+			empblock[0] = 0;
+			placer = 1;
+			tour = 0;
+		}
+	}
+	return 0;
+}
+
+void Efface(){						/* Efface l'affichage du haut */
+	ChoisirCouleurDessin(CouleurParNom("white"));
+	RemplirRectangle(0, 0, 650, 50);
+	ChoisirCouleurDessin(CouleurParNom("black"));
+}

comportementJCJ.h

@@ -0,0 +1,9 @@
+#ifndef COMPORTEMENTJCJ_H
+#define COMPORTEMENTJCJ_H
+
+
+int compJCJ(int taille);
+
+void Efface();
+
+#endif

coordoner.c

@@ -0,0 +1,34 @@
+#include "initialisation.h"
+
+int coordonerX(int SourisX){
+	int x = 0, z = 0;
+	for(z = 50; z <= 500; z += 50){
+		if(SourisX > z){		/* Récupère les coordonnées par rapport a l'emplacement du sprite */
+			x = z + 5;
+		}
+	}
+	return x;
+}
+
+
+int coordonerY(int SourisY){
+	int x = 0, z = 0;
+	for(z = 100; z <= 550; z += 50){
+		if(SourisY > z){		/* de même que le code mis en haut */
+			x = z + 5;
+		}
+	}
+	return x;
+}
+
+
+void VerifBlock1(int SourisX, int SourisY, int maxX, int maxY, int taille, int* coordoner){
+        int placementX = 0, placementY = 0;
+        if(SourisX >= 50 && SourisX <= maxX && SourisY >= 100 && SourisY <= maxY){
+                placementX = initialisationXbox(SourisX, maxX, taille);			/* récupère l'index de la case selectionner par le joueur */
+                placementY = initialisationYbox(SourisY, maxY, taille);
+        }
+        coordoner[0] = placementX;
+        coordoner[1] = placementY;
+}
+

coordoner.h

@@ -0,0 +1,11 @@
+#ifndef COORDONER_H
+#define COORDONER_H
+
+
+int coordonerX(int SourisX);
+
+int coordonerY(int SourisY);
+
+void VerifBlock1(int SourisX, int SourisY, int maxX, int maxY, int taille, int* coordoner);
+
+#endif

definirMaxXY.c

@@ -0,0 +1,38 @@
+
+
+/*
+ * 3 : x = 200 y = 250
+ * 4 : x = 250 y = 300
+ * 5 : x = 300 y = 350
+ * 6 : x = 350 y = 400
+ * 7 : x = 400 y = 450
+ * 8 : x = 450 y = 500
+ * 9 : x = 500 y = 550
+ *
+ * Les deux codes permettent de définir la taille maximale en pixel
+ */
+
+int DefMaxX(int taille){
+	int maxX = 0, x = 0, max = 200;
+	if(taille == 3){
+		maxX = 200;
+	}
+	for(x = 3; x < 10; x++){
+		if(taille == x){
+			maxX = max;
+		}
+		max += 50;
+	}
+	return maxX;
+}
+
+int DefMaxY(int taille){
+	int maxY = 0, x = 0, max = 250;
+	for(x = 3; x < 10; x++){
+		if(taille == x){
+			maxY = max;
+		}
+		max += 50;
+	}
+	return maxY;
+}

definirMaxXY.h

@@ -0,0 +1,9 @@
+#ifndef DEFINIRMAXXY_H
+#define DEFINIRMAXXY_H
+
+
+int DefMaxX(int taille);
+int DefMaxY(int taille);
+
+
+#endif

deplacement.c

@@ -1,50 +0,0 @@
-#include <stdio.h>
-
-
-int pionX = 2, pionY = 2; 
-int _X, _Y;  
-
-void deplacerPion(int clicX, int clicY) {
-    int cibleX = clicY / TAILLE_CASE;
-    int cibleY = clicX / TAILLE_CASE;
-
-   
-    if ((cibleX >= 0 && cibleX < TAILLE_GRILLE) && (cibleY >= 0 && cibleY < TAILLE_GRILLE)) {
-        if ((cibleX == pionX && (cibleY == pionY + 1 || cibleY == pionY - 1)) ||
-            (cibleY == pionY && (cibleX == pionX + 1 || cibleX == pionX - 1))) {
-            pionX = cibleX;
-            pionY = cibleY;
-            printf("Pion déplacé à (%d, %d)\n", pionX, pionY);
-        } else {
-            printf("Clic hors des cases adjacentes.\n");
-        }
-    } else {
-        printf("Clic en dehors de la grille.\n");
-    }
-}
-
-int main(void) {
-    printf("Bienvenue! Cliquez sur une case adjacente pour déplacer le pion.\n");
-
-    int running = 1;
-    while (running) {
-        afficherGrille();
-        
-       
-        if (SourisCliquee()) {
-
-            deplacerPion(_X, _Y);
-        }
-
-       
-        printf("Appuyez sur 'q' pour quitter ou cliquez pour continuer : ");
-        char quit;
-        scanf(" %c", &quit);
-        if (quit == 'q') {
-            running = 0;
-        }
-    }
-
-    printf("Fin du programme.\n");
-    return 0;
-}

grille.c

@@ -1,23 +0,0 @@
-#include <stdio.h>
-
-
-#include "taille.h"
-
-
-void Grille(int taillegrille){
-	int x, y;
-	int tabgrille[taillegrille + 2][taillegrille + 2];
-	for(x = 0; x < taillegrille + 2; x++){
-		for(y = 0; y < taillegrille + 2; y++){
-			tabgrille[x][y] = 0;
-			if(x == 0 || x == taillegrille + 1){
-				tabgrille[x][y] = 9;
-			}
-			if(y == 0 || y == taillegrille + 1){
-				tabgrille[x][y] = 9;
-			}
-			printf("%d", tabgrille[x][y]);
-		}
-		printf("\n");
-	}
-}

grille.h

@@ -1,9 +0,0 @@
-#ifndef GRILLE_H
-#define GRILLE_H
-
-
-
-void Grille(int taillegrille);
-
-
-#endif

initialisation.c

@@ -0,0 +1,58 @@
+int initialisationX(int SourisX, int maxX, int taille){
+	int casejoueur = 0, x = 0, y = 50, verou = 0;
+	for(x = 0; x <= taille; x++){
+		if(SourisX >= 50 && SourisX <= maxX){
+			if(SourisX <= y && verou == 0){
+				casejoueur = x;
+				verou++;
+			}		/* code qui retourne l'index X de la case du joueur */
+			y += 50;
+		}
+	}
+	return casejoueur;
+}
+
+int initialisationY(int SourisY, int maxY, int taille){
+	int casejoueur = 0, x = 0, y = 100, verou = 0;
+	for(x = 0; x <= taille; x++){
+		if(SourisY >= 100 && SourisY <= maxY){
+			if(SourisY <= y && verou == 0){
+				casejoueur = x;
+				verou++;
+			}		/* code qui retourne l'index Y de la case du joueur */
+			y += 50;
+		}
+	}
+	return casejoueur;
+}
+
+
+
+int initialisationXbox(int SourisX, int maxX, int taille){
+	int caseblock = 0, x = 0, y = 50, verou = 0;
+	for(x = 0; x <= taille; x++){
+		if(SourisX >= 50 && SourisX <= maxX){
+			if(SourisX <= y && verou == 0){
+				caseblock = x;
+				verou++;	/* code qui retourne l'index X de la case du block */
+			}
+			y += 50;
+		}
+	}
+	return caseblock;
+}
+
+
+int initialisationYbox(int SourisY, int maxY, int taille){
+	int caseblock = 0, x = 0, y = 100, verou = 0;
+	for(x = 0; x <= taille; x++){
+		if(SourisY >= 100 && SourisY <= maxY){
+			if(SourisY <= y && verou == 0){
+				caseblock = x;
+				verou++;	/* code qui retourne l'index Y de la case du block */
+			}
+			y += 50;
+		}
+	}
+	return caseblock;
+}

initialisation.h

@@ -0,0 +1,12 @@
+#ifndef INITIALISATION_H
+#define INITIALISATION_H
+
+int initialisationX(int SourisX, int maxX, int taille);
+
+int initialisationY(int SourisY, int maxY, int taille);
+
+int initialisationXbox(int SourisX, int maxX, int taille);
+
+int initialisationYbox(int SourisY, int maxY, int taille);
+
+#endif

jeu.c

@@ -1,16 +0,0 @@
-#include <graph.h>
-#include <stdio.h>
-
-
-
-
-
-void GraphJeu(){
-	int x = 50, y = 50, xx = 150, yy = 50, i = 0;
-	printf("fichier jeu.c taille variable\n");
-	DessinerSegment(x, y, xx, yy);
-	for(i = 0; i < 9; i++){
-		DessinerSegment(x, y * i, xx * i, yy * i);
-	}
-	while(1){}
-}

jeu.h

@@ -1,8 +0,0 @@
-#ifndef JEU_H
-#define JEU_H
-
-
-void GraphJeu();
-
-
-#endif

main.c

@@ -1,18 +1,63 @@
 #include <graph.h>
-#include <stdio.h>
 #include <stdlib.h>
 
 
 #include "menu.h"
-#include "jeu.h"
-
-
+#include "comportementJCJ.h"
+#include "comportementJCIA.h"
 
 int main (void){
+	int victoire = 0, choix = 0, SourisX = 0, SourisY = 0;
 	InitialiserGraphique();
-	CreerFenetre(50, 50, 700, 500);
-	EffacerEcran(CouleurParNom("white"));
-	Menu();
-	GraphJeu();
-	return EXIT_SUCCESS;
+	CreerFenetre(50, 50, 700, 500);		/* Initialise la fenetre puis lance le programme jeu.c qui lancera d'autre programme */
+	while(1){				/* Boucle infinie pour le jeu la seul façons d'arreter le jeu hors de la croix de la fenetre est de cliquer sur quitter une fois une partie fini */
+		choix = 0;
+		SourisX = 0;
+		SourisY = 0;
+		EffacerEcran(CouleurParNom("white"));
+		victoire = Jeu();		/* Lance le jeu pour la première fois */
+		FermerGraphique();
+		InitialiserGraphique();
+		CreerFenetre(50, 50, 700, 500);
+		while(choix == 0){
+			ChoisirCouleurDessin(CouleurParNom("black"));
+			DessinerRectangle(100, 100, 200, 50);
+			EcrireTexte(120, 135, "Rejouer ?", 2);		/* Affiche les bouttons pour rejouer ou alors quitter */
+			DessinerRectangle(400, 100, 200, 50);
+			EcrireTexte(420, 135, "Quitter ?", 2);
+			if(SourisCliquee()){
+				SourisX = _X;
+				SourisY = _Y;
+			}
+			if(SourisX <= 300 && SourisX >= 100 && SourisY <= 150 && SourisY >= 100){
+				choix++;	/* Fonction qui dit juste que le joueur veux rejouer donc change la variable de la boucle while */
+			}else if(SourisX <= 600 && SourisX >= 400 && SourisY <= 150 && SourisY >= 100){
+				choix = 5;
+			}
+			if(victoire == 1){
+				EcrireTexte(200, 235, "Joueur 1 a gagner !", 2);
+			}else if (victoire == 2){
+				EcrireTexte(200, 235, "Joueur 2 a gagner !", 2);		/* Affiche le gagnant */
+			}else if (victoire == 3){
+				EcrireTexte(200, 235, "L'IA a gagner !", 2);
+			}
+			if(choix == 5){
+				FermerGraphique();
+				return EXIT_SUCCESS;						/* Ferme le programme */
+			}
+		}
+	}
+}
+
+
+int Jeu(){
+	int choix[2], taille = 0, victoire = 0;
+	Menu(choix);
+	taille = choix[1];
+	if(choix[0] == 1){
+		victoire = compJCJ(taille);
+	}else if (choix[0] == 2){
+		victoire = compJCIA(taille);
+	}
+	return victoire;
 }

menu.c

@@ -1,30 +1,18 @@
 #include <graph.h>
-#include <stdio.h>
 
 #include "taille.h"
 #include "nbjoueur.h"
-#include "nbjoueur2.h"
-#include "boutonJVJ.h"
-#include "jeu.h"
 
 
-int Menu() {
-	int x = 100, y = 100, taille = -5, choix = 0, echotaille = 0, verrou = 0; 	/* initialisation des variable */
+void Menu(int *retour) {
+	int x = 50, y = 50, taille = -5, choix = 0, echotaille = 0, verrou = 0; 	/* initialisation des variable */
 	couleur c = CouleurParNom("white");
-	while(choix == 0){				/* Changer la condition pour que le menu s'arrête quand le joueur aura selectionner le nombre de joueur */
-		if(taille == -5){
-			ChoisirCouleurDessin(CouleurParNom("black"));
-			EcrireTexte(x, y, "Taille de grille entre 3 et 9 :", 2);	/* Implémentation du texte */
-			ChoisirCouleurDessin(CouleurParNom("red"));
-			EcrireTexte(x, y + 50, "Attente du choix de l'utilisateur...", 2);
-		}
-		
-		taille = GererChoixTaille();
-	
+	while(choix == 0){		/* Condition pour que le menu s'arrête quand le joueur aura selectionner le nombre de joueur */
+		ChoisirCouleurDessin(CouleurParNom("black"));
+		EcrireTexte(x, y, "Taille de grille entre 3 et 9 :", 2);
+		taille = GererChoixTaille();		/* Récupération de la taille de la grille */
 		/* Demande a taille sa valeur pour la comparé pour savoir si menu peu passer a la selection de joueur */
-
 		if(taille > 2 && taille < 10){
-			printf("taille de menu %d\n\n", taille);
 			EffacerEcran(c);
 			if(verrou == 0){
 				echotaille = taille;
@@ -41,10 +29,58 @@ int Menu() {
 			}
 		}
 	}
-	printf("choix de menu %d\n", choix);
         FermerGraphique();
         InitialiserGraphique();
-	/* Demander a Luck quel est la taille de fenetre max qu'il peut voir sur son écran pour corriger les SAE */
-        CreerFenetre(50, 50, 600, 600);
-	return choix;
+	CreerFenetre(50, 50, 650, 650);
+	Grille(echotaille);		/* Lancement du code qui affiche la grille */
+	retour[0] = choix;
+	retour[1] = echotaille;
 }
+
+
+
+void Grille(int taille){
+        int bord = 0, x = 100, xx = 50, y = 100, yy = 100;
+        ChoisirCouleurDessin(CouleurParNom("Black"));
+        for(bord = 0; bord < taille; bord++){
+                DessinerSegment(50, 100, x, 100);       /* Dessine le bord du haut de la grille */
+                x += 50;
+        }
+        x -= 50;                			/* Enlève le surplus de la fonction for */
+        for(bord = 0; bord <= taille; bord++){
+                DessinerSegment(50, 100, 50 , y);       /* Dessine les barre latérale en fonction de la taille choisie */
+                DessinerSegment(x, 100, x, y);
+                y += 50;
+        }
+        y -= 50;					/* Enlève le surplus de la fonction for */
+        DessinerSegment(50, y, x, y);
+        for(bord = 0; bord <= taille; bord++){
+                DessinerSegment(50, yy, x, yy);         /* Dessine les barre horizontale de l'intérieur de la grille */
+                yy += 50;
+        }
+        for(bord = 0; bord <= taille; bord++){
+                DessinerSegment(xx, 100, xx, y);        /* Dessine les barre verticale de l'intérieur de la grille */
+                xx += 50;
+        }
+}
+
+
+
+/* Fonction qui permet de délimiter le clique de la souris pour le bouton de Joueur contre Joueur */
+
+int boutonJVJ(){
+        int choix = 0, SourisX = 0, SourisY = 0;
+        while(choix == 0){                              /* Boucle effectif tant que le joueur n'a pas fais de choix */
+                if (SourisCliquee()){   /* Détecte quand le joueur clique et met les coordonées du clique de SourisX et Souris Y */
+                        SourisX = _X;
+                        SourisY = _Y;
+                }
+                if(SourisX > 100 && SourisX < 250 && SourisY > 150 && SourisY < 200){
+                        choix = 1;              /* Quand le joueur clique dans l'emplacement de Joueur contre Joueur choix = 1 */
+                }else if(SourisX > 400 && SourisX < 550 && SourisY > 150 && SourisY < 200){
+                        choix = 2;              /* Quand le joueur cliqye dans l'emplacement de Joueur contre IA choix = 2 */
+                }
+        }
+        return choix;   /* On retourne choix pour que le menu puisse le retourner a jeu.c pour faire la selection de l'ennemie */
+}
+

menu.h

@@ -2,8 +2,10 @@
 #define MENU_H
 
 
+void Menu(int *retour);
 
+void Grille(int taille);
 
-int Menu();
+int boutonJCJ();
 
 #endif

nbjoueur.c

@@ -7,7 +7,7 @@
 
 
 
-int nbjoueur(){
+void nbjoueur(){
 	int x = 100, xx = 250, y = 150, l = 30, h = 30, angle1 = 20, angle2 = 30;
 	ChoisirCouleurDessin(CouleurParNom("Black"));
 	DessinerSegment(x, y, xx, y);
@@ -20,3 +20,24 @@ int nbjoueur(){
 	DessinerSegment(x - 8, y + 9, x - 8, y + 43);
 	DessinerSegment(xx + 6, y + 8, xx + 6, y + 43);
 }
+
+
+
+/*
+ * Fonction qui permet de déssiner le bouton du joueur contre IA
+ */
+
+void nbjoueur2(){
+        int x = 400, xx = 550, y = 150, l = 30, h = 30, angle1 = 20, angle2 = 30;
+        ChoisirCouleurDessin(CouleurParNom("Black"));
+        DessinerSegment(x, y, xx, y);
+        DessinerSegment(x - 2, y + 50, xx, y + 50);
+        EcrireTexte(x + 10, y + 35, "J1 VS IA", 2);
+        DessinerArc(xx - 23, y - 3, l, h, angle1, angle2);
+        DessinerArc(x - 9, y - 2, l, h, angle1 + 100, angle2 + 10);
+        DessinerArc(xx - 23, y + 23, l, h, angle1 + 290, angle2);
+        DessinerArc(x - 9, y + 23, l, h, angle1 + 180, angle2);
+        DessinerSegment(x - 8, y + 9, x - 8, y + 43);
+        DessinerSegment(xx + 6, y + 8, xx + 6, y + 43);
+}
+

nbjoueur.h

@@ -2,7 +2,8 @@
 #define NBJOUEUR_H
 
 
-int nbjoueur();
+void nbjoueur();
 
+void nbjoueur2();
 
 #endif

nbjoueur2.c

@@ -1,23 +0,0 @@
-#include <graph.h>
-
-
-
-/*
- * Fonction qui permet de déssiner le bouton du joueur contre IA
- */
-
-
-
-int nbjoueur2(){
-	int x = 400, xx = 550, y = 150, l = 30, h = 30, angle1 = 20, angle2 = 30;
-	ChoisirCouleurDessin(CouleurParNom("Black"));
-	DessinerSegment(x, y, xx, y);
-	DessinerSegment(x - 2, y + 50, xx, y + 50);
-	EcrireTexte(x + 10, y + 35, "J1 VS IA", 2);
-	DessinerArc(xx - 23, y - 3, l, h, angle1, angle2);
-	DessinerArc(x - 9, y - 2, l, h, angle1 + 100, angle2 + 10);
-	DessinerArc(xx - 23, y + 23, l, h, angle1 + 290, angle2);
-	DessinerArc(x - 9, y + 23, l, h, angle1 + 180, angle2);
-	DessinerSegment(x - 8, y + 9, x - 8, y + 43);
-	DessinerSegment(xx + 6, y + 8, xx + 6, y + 43);
-}

nbjoueur2.h

@@ -1,8 +0,0 @@
-#ifndef NBJOUEUR2_H
-#define NBJOUEUR2_H
-
-
-int nbjoueur2();
-
-
-#endif

pion.c

@@ -1,4 +0,0 @@
-<<<<<<< HEAD
-
-=======
->>>>>>> f21a4c872d10db76a298caf1b13782029be1130e

taille.c

@@ -1,40 +1,86 @@
 #include <graph.h>
-#include <stdio.h>
 
 
-#include "taille.h"
-#include "grille.h"
+/* Fonction qui affiche le cadre des bouttons et affiche une image représentant la taille du tableau disponible */
+void AfficherSelectionBoutton(){
+	DessinerSegment(100, 100, 150, 100);
+	DessinerSegment(100, 200, 150, 200);
+	DessinerSegment(100, 100, 100, 200);
+	DessinerSegment(150, 100, 150, 200);
+	ChargerSprite("./image/3.png");
+	AfficherSprite(1, 100, 100);
+
+	DessinerSegment(200, 100, 250, 100);
+	DessinerSegment(200, 200, 250, 200);
+	DessinerSegment(200, 200, 200, 100);
+	DessinerSegment(250, 200, 250, 100);
+	ChargerSprite("./image/4.png");
+	AfficherSprite(2, 200, 100);
+
+	DessinerSegment(300, 100, 350, 100);
+	DessinerSegment(300, 200, 350, 200);
+	DessinerSegment(300, 100, 300, 200);
+	DessinerSegment(350, 100, 350, 200);
+	ChargerSprite("./image/5.png");
+	AfficherSprite(3, 300, 100);
+	
+	DessinerSegment(400, 100, 450, 100);
+	DessinerSegment(400, 200, 450, 200);
+	DessinerSegment(400, 100, 400, 200);
+	DessinerSegment(450, 100, 450, 200);
+	ChargerSprite("./image/6.png");
+	AfficherSprite(4, 400, 100);
+	
+	DessinerSegment(500, 100, 550, 100);
+	DessinerSegment(500, 200, 550, 200);
+	DessinerSegment(500, 100, 500, 200);
+	DessinerSegment(550, 100, 550, 200);
+	ChargerSprite("./image/7.png");
+	AfficherSprite(5, 500, 100);
+	
+	DessinerSegment(100, 250, 150, 250);
+	DessinerSegment(100, 350, 150, 350);
+	DessinerSegment(100, 250, 100, 350);
+	DessinerSegment(150, 250, 150, 350);
+	ChargerSprite("./image/8.png");
+	AfficherSprite(6, 100, 250);
+	
+	DessinerSegment(200, 250, 250, 250);
+	DessinerSegment(200, 350, 250, 350);
+	DessinerSegment(200, 250, 200, 350);
+	DessinerSegment(250, 250, 250, 350);
+	ChargerSprite("./image/9.png");
+	AfficherSprite(7, 200, 250);
+}
+
 
 
 /* Code permettant de choisir la taille de la grille en fonction du chiffre que l'utilisateur a entrer qui est compris entre 3 et 9 */
 
-
 int GererChoixTaille(){
-	int taillegrille = 1;
-	if(taillegrille == 1){
-		if(ToucheEnAttente()){
-			KeySym touchPresse = Touche();		/* Prend en compte la touche presser et renvoie la touche presser */
-			if(touchPresse == XK_KP_3 || touchPresse == XK_3){
-				taillegrille = 3;
-			} else if(touchPresse == XK_KP_4 || touchPresse == XK_4){
-				taillegrille = 4;
-			} else if(touchPresse == XK_KP_5 || touchPresse == XK_5){
-				taillegrille = 5;
-			} else if(touchPresse == XK_KP_6 || touchPresse == XK_6){
-				taillegrille = 6;
-			} else if(touchPresse == XK_KP_7 || touchPresse == XK_7){
-				taillegrille = 7;
-			} else if(touchPresse == XK_KP_8 || touchPresse == XK_8){
-				taillegrille = 8;
-			} else if(touchPresse == XK_KP_9 || touchPresse == XK_9){
-				taillegrille = 9; 
-			}
+	int taille = 0, SourisX = 0, SourisY = 0;
+	while(taille == 0){
+		AfficherSelectionBoutton();
+		if(SourisCliquee()){
+			SourisX = _X;		/* Met les coordonés de la souris si le joueur a cliquer dans SourisX et SourisY */
+			SourisY = _Y;
+		}
+		/* Vérifi si le joueur a cliquer dans la zone d'un des choix de taille de grille */
+		if(SourisX >= 100 && SourisX <= 150 && SourisY >= 100 && SourisY <= 200){
+			taille = 3;
+		}else if(SourisX >= 200 && SourisX <= 250 && SourisY >= 100 && SourisY <= 200){
+			taille = 4;
+		}else if(SourisX >= 300 && SourisX <= 350 && SourisY >= 100 && SourisY <= 200){
+			taille = 5;
+		}else if(SourisX >= 400 && SourisX <= 450 && SourisY >= 100 && SourisY <= 200){
+			taille = 6;
+		}else if(SourisX >= 500 && SourisX <= 550 && SourisY >= 100 && SourisY <= 200){
+			taille = 7;
+		}else if(SourisX >= 100 && SourisX <= 150 && SourisY >= 250 && SourisY <= 350){
+			taille = 8;
+		}else if(SourisX >= 200 && SourisX <= 250 && SourisY >= 250 && SourisY <= 350){
+			taille = 9;
 		}
 	}
-	if(taillegrille != 1){
-	/* Prend taillegrille et l'envoie dans le fichier Grille pour initialisation de la grille du jeu */
-		printf("taille grille de taille %d\n", taillegrille);
-		Grille(taillegrille);
-		return taillegrille;
-	}
+	return taille;
 }

taille.h

@@ -5,6 +5,6 @@
 
 
 int GererChoixTaille();
-
+void AfficherSelectionBoutton();
 
 #endif