repost

Makefile

@@ -0,0 +1,44 @@
+### Leni Boscher # Tanguy Domergue ###
+
+### VARIABLES ###
+
+CC = gcc
+
+CFLAGS = -Wall \
+		 -ansi \
+		 -pedantic\
+
+OPTION = -lgraph
+
+EXE = ./blocus
+
+OFILES = main.o \
+		 menu.o \
+		 plateau.o \
+		 regles.o \
+		
+
+### BUT ###
+
+but: ${EXE}
+
+### CONDITIONS ###
+
+plateau.o : plateau.h regles.h main.h
+
+regles.o : plateau.h regles.h
+
+main.o : menu.h regles.h plateau.h main.h
+
+menu.o : menu.h
+
+${EXE}: ${OFILES} 
+		$(CC) $(CFLAGS) -o ${EXE} ${OFILES} $(OPTION)
+
+### CONDITIONS FACULTATIVES ###
+
+clean: 
+	-rm -f ${OFILES} ${EXE}
+
+run:
+	${EXE}

main.c

@@ -0,0 +1,27 @@
+/* Leni Boscher * Tanguy Domergue */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <graph.h>
+#include"main.h"
+#include"menu.h"
+#include"plateau.h"
+#include"regles.h"
+
+
+int main(void){
+	int number, versus;
+	InitialiserGraphique();
+	CreerFenetre(10,10, LargeF, HautF);
+	if (accueil(&number, &versus)==0)return EXIT_SUCCESS;
+	while(1) {
+		if(SourisCliquee()) {
+			if (_X>=322 && _X<=426 && _Y>=453 && _Y<=511){
+        	FermerGraphique();
+			plateau(number, versus);
+			break;
+			}
+		}
+	}
+  return EXIT_SUCCESS;
+  }

main.h

@@ -0,0 +1,9 @@
+#ifndef MAIN_H
+#define MAIN_H
+
+#define LargeF 750 /*largeur de la fenetre*/
+#define HautF 550 /* hauteur de la fenetre */
+
+int main(void);
+
+#endif

menu.c

@@ -0,0 +1,146 @@
+/* Boscher Leni * Domergue Tanguy */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <graph.h>
+#include"plateau.h"
+
+void backaccueil(int sortir){ /* cette fonction permet de revenir sur l'écran principale */
+	if(sortir>=0){
+
+		while(SourisCliquee()){
+			if (_X>=21 && _X<=168  && _Y>=20 && _Y<=52){
+				FermerGraphique();
+				main();
+			}
+		}
+	}
+}
+
+
+int gameplay(){ /*( affiche rectangle autour de utilisateur vs ia / utilisateur vs j2 et renvoie une valeur en fonction du choix)*/
+	int sortir = 0;
+	couleur rouge= CouleurParNom("red");
+
+	while(sortir == 0){
+
+		while(SourisCliquee()){
+
+			if(_X>=158 && _X<=441 && _Y>=392 && _Y<=422){
+				ChoisirCouleurDessin(rouge);
+				DessinerRectangle(158,392,(441-158),(422-392));
+				sortir++;
+                return 2;
+			}
+
+			else if (_X>=442 && _X<=724 && _Y>=392 && _Y<=422){
+				ChoisirCouleurDessin(rouge);
+				DessinerRectangle(442,392,(724-442),(422-392));
+				sortir++;
+                return 1;
+			}
+			if (_X>=21 && _X<=168  && _Y>=20 && _Y<=52){
+				FermerGraphique();
+				main();
+                return 0;
+			}
+		}
+	}
+}
+
+int dimensions(){ /* (affiche rectangle autour des dimensions choisis par l'utilisateur et renvoie une valeur en fonction de celle-ci ) */
+	int sortir = 0;
+	couleur rouge= CouleurParNom("red");
+
+	while(sortir == 0){
+
+		while(SourisCliquee()){
+
+			if(_X>=158 && _X<=239 && _Y>=341 && _Y<=368){
+				ChoisirCouleurDessin(rouge);
+				DessinerRectangle(158,341,(239-158),(371-341));
+                sortir++;
+				return 3;
+			}
+
+			if(_X>=239 && _X<=321 && _Y>=341 && _Y<=368){
+				ChoisirCouleurDessin(rouge);
+				DessinerRectangle(239,341,(321-239),(371-341));
+                sortir++;
+				return 4;
+			}
+
+			if(_X>=320 && _X<=402 && _Y>=341 && _Y<=368){
+				ChoisirCouleurDessin(rouge);
+				DessinerRectangle(320,341,(403-320),(371-341));
+                sortir++;
+				return 5;
+			}
+
+			if(_X>=402 && _X<=483 && _Y>=341 && _Y<=368){
+				ChoisirCouleurDessin(rouge);
+				DessinerRectangle(402,341,(483-402),(371-341));
+                sortir++;
+				return 6;
+			}
+
+			if(_X>=483 && _X<=564 && _Y>=341 && _Y<=368){
+				ChoisirCouleurDessin(rouge);
+				DessinerRectangle(483,341,(564-483),(371-341));
+                sortir++;
+				return 7;
+			}
+
+			if(_X>=565 && _X<=645 && _Y>=341 && _Y<=368){
+				ChoisirCouleurDessin(rouge);
+				DessinerRectangle(565,341,(645-565),(371-341));
+                sortir++;
+				return 8;
+			}
+
+			if(_X>=645 && _X<=724 && _Y>=341 && _Y<=368){
+				ChoisirCouleurDessin(rouge);
+				DessinerRectangle(645,341,(724-645),(371-341));
+				sortir++;
+                return 9;
+			}
+			if (_X>=21 && _X<=168  && _Y>=20 && _Y<=52){
+				FermerGraphique();
+				main();
+                return 0;
+			}
+		}
+	}
+}	
+
+
+
+int accueil(int* number, int* versus){ 	/*Fonction qui lance la premiere page d'accueil ( permet d'aller vers exit ou jouer (reglage))*/
+	ChargerImageFond("./img/menu.png");
+
+	while(1){
+		if (SourisCliquee()){
+            if(_X>=490 && _X<=600  && _Y>=436 && _Y<=488 ){ 
+			    FermerGraphique();
+                return 0;
+		    }	
+	
+			if (_X>=616 && _X<=725  && _Y>=438 && _Y<=490)
+			{
+				ChargerImageFond("./img/reglage.png");
+				*number = dimensions();
+				*versus = gameplay();
+                return 1;
+		    }
+            
+			}
+			if (_X>=21 && _X<=168  && _Y>=20 && _Y<=52){
+					FermerGraphique();
+					main();
+			}
+		}
+	}	
+
+
+
+

menu.h

@@ -0,0 +1,11 @@
+#ifndef MENU_H
+#define MENU_H
+
+void reglage();
+int accueil(int* number, int* versus);
+void quitter();
+int dimensions();
+int gameplay();
+void backaccueil(int sortir);
+
+#endif /* MENU_H */

plateau.c

@@ -0,0 +1,425 @@
+/* Leni Boscher * Tanguy Domergue */
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<graph.h>
+#include<time.h>
+#include<unistd.h>
+#include"regles.h"
+#include"plateau.h"
+#include"menu.h"
+#include"main.h"
+
+/* Main */
+
+
+
+int plateau(int dim, int nb_joueurs) {
+taille = dim;
+decalage = ((TAILLE_WINDOW-DIMENSIONS)/2);
+srand(time(NULL));
+couple pion;
+couple indice;
+int jouer=1;
+int tailleCase =  DIMENSIONS/taille;
+int i;
+int j;
+couleur c;
+int win=0;
+
+tab=malloc((taille+2)*sizeof(tile));
+for(i=0;i<taille+2;i++){
+    tab[i]=malloc((taille+2)*sizeof(tile));
+}
+
+InitialiserGraphique();
+CreerFenetre(10,10,TAILLE_WINDOW,TAILLE_WINDOW);
+for(i=0;i<taille;i++) {
+    DessinerSegment(decalage+(tailleCase)*i,decalage,decalage+(tailleCase)*i,DIMENSIONS+decalage);
+        for(j=0;j<taille;j++) { /* Cette boucle stocke dans le tableau des cases les coordonnées du coin haut gauche de chaques cases */
+            tab[i+1][j+1].coord.x = decalage+(tailleCase)*i;
+            tab[i+1][j+1].coord.y = decalage+(tailleCase)*j;
+            tab[i+1][j+1].etat = 0;
+        }
+    DessinerSegment(decalage,decalage+(tailleCase)*i,DIMENSIONS+decalage,decalage+(tailleCase)*i); 
+}
+DessinerSegment(decalage+(tailleCase)*i+1,decalage,decalage+(tailleCase)*i+1,DIMENSIONS+decalage);
+DessinerSegment(decalage,decalage+(tailleCase)*i+1,DIMENSIONS+decalage,decalage+(tailleCase)*i+1); 
+
+
+/* initialisation du tableau de l'etat des bordures */
+
+for(i=0;i<taille+2;i++) {
+    tab[i][0].etat = -1;
+    tab[0][i].etat = -1;
+    tab[taille+1][i].etat = -1;
+    tab[i][taille+1].etat = -1;
+}
+
+
+/* Placer les premiers pions */
+if (nb_joueurs==2) {
+    jouer=1;
+    while (1) {
+        if (SourisCliquee()==1) {
+            SourisPosition();
+            indice = calculIndice(_X, _Y);
+            if (caseVerif(indice)==1) {
+            if (jouer==1) {
+                if (taille==3) /* Cette succession de if adapte la taille de l'image des pions bleus aux dimensions choisies par l'utilisateur :
+                                * Il y a 7 dimensions possibles, et 7 images différentes pour chaques dimensions */
+                    ChargerImage("./img/pion_bleu3.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                if (taille==4)
+                    ChargerImage("./img/pion_bleu4.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                if (taille==5)
+                    ChargerImage("./img/pion_bleu5.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                if (taille==6)
+                    ChargerImage("./img/pion_bleu6.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                if (taille==7)
+                    ChargerImage("./img/pion_bleu7.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                if (taille==8)
+                    ChargerImage("./img/pion_bleu8.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                if (taille==9)
+                    ChargerImage("./img/pion_bleu9.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+            } else if (jouer==3){
+                if (taille==3) /* Cette succession de if adapte la taille de l'image des pions oranges aux dimensions choisies par l'utilisateur :
+                                * Il y a 7 dimensions possibles, et 7 images différentes pour chaques dimensions */
+                    ChargerImage("./img/pion_orange3.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                if (taille==4)
+                    ChargerImage("./img/pion_orange4.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                if (taille==5)
+                    ChargerImage("./img/pion_orange5.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                if (taille==6)
+                    ChargerImage("./img/pion_orange6.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                if (taille==7)
+                    ChargerImage("./img/pion_orange7.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                if (taille==8)
+                    ChargerImage("./img/pion_orange8.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                if (taille==9)
+                    ChargerImage("./img/pion_orange9.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2);         }
+                tab[indice.x][indice.y].etat=jouer;
+            if(jouer==3) break;
+                jouer=3;
+            }
+        }
+    }
+
+    AfficherTableau(); 
+
+    /* Tours de jeu, les joueurs déplacent chacun un pion, puis placent une croix, à tours de rôle */
+    jouer=1;
+    while (1) {
+        while(SourisCliquee()==1) {
+                if(jouer==1) {
+                    SourisPosition();
+                    indice = calculIndice(_X, _Y);
+                    pion = chercherPion(jouer);
+                        if ((caseVerif(indice)==1 && (deplacAdj(indice, pion)==1))) {
+                            tab[pion.x][pion.y].etat = 0;
+                            CopierZone(0, 0, tab[pion.x][pion.y].coord.x+1, tab[pion.x][pion.y].coord.y+1, tailleCase-2, tailleCase-2, tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1);
+                            c=CouleurParNom("white");
+                            ChoisirCouleurDessin(c);
+                            RemplirRectangle(tab[pion.x][pion.y].coord.x+1, tab[pion.x][pion.y].coord.y+1, tailleCase-2, tailleCase-2);
+                            tab[indice.x][indice.y].etat=jouer;
+                            jouer++;
+
+                        AfficherTableau();
+
+                        }
+                    break;
+
+                }
+                if(winCondition(chercherPion(1), chercherPion(3))==1) {
+                    break;
+                }
+
+                if(jouer==2) {
+                    SourisPosition();
+                    indice = calculIndice(_X, _Y); 
+                        if ((caseVerif(indice)==1)) {
+                                if (taille==3) /* Cette succession de if adapte la taille de l'image des croix bleues aux dimensions choisies par l'utilisateur :
+                                                * Il y a 7 dimensions possibles, et 7 images différentes pour chaques dimensions */
+                                    ChargerImage("./img/croix_bleue3.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==4)
+                                    ChargerImage("./img/croix_bleue4.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==5)
+                                    ChargerImage("./img/croix_bleue5.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==6)
+                                    ChargerImage("./img/croix_bleue6.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==7)
+                                    ChargerImage("./img/croix_bleue7.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==8)
+                                    ChargerImage("./img/croix_bleue8.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==9)
+                                    ChargerImage("./img/croix_bleue9.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                            tab[indice.x][indice.y].etat=jouer;
+                            jouer++;
+
+                        AfficherTableau();
+
+                        }
+                    break;
+                }
+            
+                if(winCondition(chercherPion(1), chercherPion(3))==1) {
+                    break;
+                }
+
+                if(jouer==3) {
+                    SourisPosition();
+                    indice = calculIndice(_X, _Y);
+                    pion = chercherPion(jouer);
+                        if (caseVerif(indice)==1 && deplacAdj(indice, pion)==1) {
+                            tab[pion.x][pion.y].etat = 0;
+                            CopierZone(0, 0, tab[pion.x][pion.y].coord.x+1, tab[pion.x][pion.y].coord.y+1, tailleCase-2, tailleCase-2, tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1);
+                            c=CouleurParNom("white");
+                            ChoisirCouleurDessin(c);
+                            RemplirRectangle(tab[pion.x][pion.y].coord.x+1, tab[pion.x][pion.y].coord.y+1, tailleCase-2, tailleCase-2);
+                            tab[indice.x][indice.y].etat=jouer;
+                            jouer++;
+
+                        AfficherTableau();
+
+                        }
+                    break;
+                }
+                if(winCondition(chercherPion(1), chercherPion(3))==1) {
+                    break;
+                }       
+                
+                if(jouer==4) {
+                    SourisPosition();
+                    indice = calculIndice(_X, _Y);
+                        if (caseVerif(indice)==1) {
+                                if (taille==3) /* Cette succession de if adapte la taille de l'image des croix oranges aux dimensions choisies par l'utilisateur :
+                                                * Il y a 7 dimensions possibles, et 7 images différentes pour chaques dimensions */
+                                    ChargerImage("./img/croix_orange3.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==4)
+                                    ChargerImage("./img/croix_orange4.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==5)
+                                    ChargerImage("./img/croix_orange5.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==6)
+                                    ChargerImage("./img/croix_orange6.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==7)
+                                    ChargerImage("./img/croix_orange7.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==8)
+                                    ChargerImage("./img/croix_orange8.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==9)
+                                    ChargerImage("./img/croix_orange9.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                            tab[indice.x][indice.y].etat=jouer;
+                            jouer = 1;
+
+                        AfficherTableau();
+
+                        }
+                    break;
+                }
+                break;
+            }
+
+        if(winCondition(chercherPion(1), chercherPion(3))==1) {
+            break;
+        }
+        
+    }
+}
+
+if(nb_joueurs==1) {
+    jouer=1;
+    while (1) {
+        if (SourisCliquee()==1) {
+            SourisPosition();
+            indice = calculIndice(_X, _Y);
+                if (caseVerif(indice)==1) {
+                    if (jouer==1) {
+                        if (taille==3) /* Cette succession de if adapte la taille de l'image des pions bleus aux dimensions choisies par l'utilisateur :
+                                        * Il y a 7 dimensions possibles, et 7 images différentes pour chaques dimensions */
+                            ChargerImage("./img/pion_bleu3.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                        if (taille==4)
+                            ChargerImage("./img/pion_bleu4.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                        if (taille==5)
+                            ChargerImage("./img/pion_bleu5.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                        if (taille==6)
+                            ChargerImage("./img/pion_bleu6.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                        if (taille==7)
+                            ChargerImage("./img/pion_bleu7.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                        if (taille==8)
+                            ChargerImage("./img/pion_bleu8.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                        if (taille==9)
+                            ChargerImage("./img/pion_bleu9.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2);                     tab[indice.x][indice.y].etat=jouer;
+                        jouer=3;
+                        if(jouer==3) break;
+                    }
+                }
+        }
+    }
+
+    while (1) {
+        if (jouer==3) {
+        _X=((rand()%DIMENSIONS)+decalage);
+        _Y=((rand()%DIMENSIONS)+decalage);
+        indice = calculIndice(_X, _Y);
+            if (caseVerif(indice)==1) {
+                if (jouer==3) {
+                    usleep(500000);
+                    if (taille==3) /* Cette succession de if adapte la taille de l'image des pions oranges aux dimensions choisies par l'utilisateur :
+                                    * Il y a 7 dimensions possibles, et 7 images différentes pour chaques dimensions */
+                        ChargerImage("./img/pion_orange3.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                    if (taille==4)
+                        ChargerImage("./img/pion_orange4.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                    if (taille==5)
+                        ChargerImage("./img/pion_orange5.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                    if (taille==6)
+                        ChargerImage("./img/pion_orange6.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                    if (taille==7)
+                        ChargerImage("./img/pion_orange7.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                    if (taille==8)
+                        ChargerImage("./img/pion_orange8.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                    if (taille==9)
+                        ChargerImage("./img/pion_orange9.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2);                 tab[indice.x][indice.y].etat=jouer;
+                if(jouer==3) break;
+                }
+            }
+        }
+    }
+    AfficherTableau(); 
+
+    /* Tours de jeu, les joueurs déplacent chacun un pion, puis placent une croix, à tours de rôle */
+    jouer=1;
+    while (1) {
+        while(SourisCliquee()==1) {
+                if(jouer==1) {
+                    SourisPosition();
+                    indice = calculIndice(_X, _Y);
+                    pion = chercherPion(jouer);
+                        if ((caseVerif(indice)==1 && (deplacAdj(indice, pion)==1))) {
+                            tab[pion.x][pion.y].etat = 0;
+                            CopierZone(0, 0, tab[pion.x][pion.y].coord.x+1, tab[pion.x][pion.y].coord.y+1, tailleCase-2, tailleCase-2, tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1);
+                            c=CouleurParNom("white");
+                            ChoisirCouleurDessin(c);
+                            RemplirRectangle(tab[pion.x][pion.y].coord.x+1, tab[pion.x][pion.y].coord.y+1, tailleCase-2, tailleCase-2);
+                            tab[indice.x][indice.y].etat=jouer;
+                            jouer++;
+
+                        AfficherTableau();
+
+                        }
+                    break;
+
+                }
+                if(winCondition(chercherPion(1), chercherPion(3))==1) {
+                    break;
+                }
+
+                if(jouer==2) {
+                    SourisPosition();
+                    indice = calculIndice(_X, _Y); 
+                        if ((caseVerif(indice)==1)) {
+                            if (taille==3) /* Cette succession de if adapte la taille de l'image des croix bleues aux dimensions choisies par l'utilisateur :
+                                                * Il y a 7 dimensions possibles, et 7 images différentes pour chaques dimensions */
+                                    ChargerImage("./img/croix_bleue3.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==4)
+                                    ChargerImage("./img/croix_bleue4.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==5)
+                                    ChargerImage("./img/croix_bleue5.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==6)
+                                    ChargerImage("./img/croix_bleue6.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==7)
+                                    ChargerImage("./img/croix_bleue7.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==8)
+                                    ChargerImage("./img/croix_bleue8.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                                if (taille==9)
+                                    ChargerImage("./img/croix_bleue9.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                            tab[indice.x][indice.y].etat=jouer;
+                            jouer++;
+
+                        AfficherTableau();
+
+                        }
+                    break;
+                }
+            
+                if(winCondition(chercherPion(1), chercherPion(3))==1) {
+                    break;
+                }
+        }
+        while (jouer==3) {
+                if(jouer==3) {
+                    _X=((rand()%DIMENSIONS)+decalage);
+                    _Y=((rand()%DIMENSIONS)+decalage);
+                    indice = calculIndice(_X, _Y);
+                    pion = chercherPion(jouer);
+                        if (caseVerif(indice)==1 && deplacAdj(indice, pion)==1) {
+                            usleep(1000000);
+                            tab[pion.x][pion.y].etat = 0;
+                            CopierZone(0, 0, tab[pion.x][pion.y].coord.x+1, tab[pion.x][pion.y].coord.y+1, tailleCase-2, tailleCase-2, tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1);
+                            c=CouleurParNom("white");
+                            ChoisirCouleurDessin(c);
+                            RemplirRectangle(tab[pion.x][pion.y].coord.x+1, tab[pion.x][pion.y].coord.y+1, tailleCase-2, tailleCase-2);
+                            tab[indice.x][indice.y].etat=jouer;
+                            jouer++;
+
+                        AfficherTableau();
+
+                        }
+                    break;
+                }
+                if(winCondition(chercherPion(1), chercherPion(3))==1) {
+                    break;
+                } 
+        }      
+            while(jouer==4){       
+                if(jouer==4) {
+                    _X=((rand()%DIMENSIONS)+decalage);
+                    _Y=((rand()%DIMENSIONS)+decalage);
+                    indice = calculIndice(_X, _Y);
+                        if (caseVerif(indice)==1) {
+                            usleep(1000000);
+                            if (taille==3) /* Cette succession de if adapte la taille de l'image des croix oranges aux dimensions choisies par l'utilisateur :
+                                                * Il y a 7 dimensions possibles, et 7 images différentes pour chaques dimensions */
+                                ChargerImage("./img/croix_orange3.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                            if (taille==4)
+                                ChargerImage("./img/croix_orange4.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                            if (taille==5)
+                                ChargerImage("./img/croix_orange5.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                            if (taille==6)
+                                ChargerImage("./img/croix_orange6.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                            if (taille==7)
+                                ChargerImage("./img/croix_orange7.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                            if (taille==8)
+                                ChargerImage("./img/croix_orange8.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                            if (taille==9)
+                                ChargerImage("./img/croix_orange9.png", tab[indice.x][indice.y].coord.x+1, tab[indice.x][indice.y].coord.y+1 , 0, 0, tailleCase-2, tailleCase-2); 
+                            tab[indice.x][indice.y].etat=jouer;
+                            jouer = 1;
+
+                        AfficherTableau();
+
+                        }
+                    break;
+                }
+                break;
+        }
+        if(winCondition(chercherPion(1), chercherPion(3))==1) {
+            break;
+        }
+        
+    }
+}
+
+
+for(i=0;i<taille+2;i++) {
+    free(tab[i]);
+}
+free(tab);
+
+while(1){
+    if (SourisCliquee()){
+        FermerGraphique();
+        main();
+    break;
+}
+}
+return 0;
+
+}

plateau.h

@@ -0,0 +1,31 @@
+#ifndef PLATEAU_H
+#define PLATEAU_H
+#include"menu.h"
+
+#define TAILLE_WINDOW 1000
+#define DIMENSIONS 920
+#define NB_JOUEURS 1
+
+int decalage;
+int taille;
+
+/* Tableau qui parcoure chaques cases de la grille, struct qui donne les couples de coordonnées du point haut gauche de chaque case */
+
+int plateau(int dim, int nb_joueurs);
+
+typedef struct couple {
+    int x;
+    int y;
+} couple;
+
+typedef struct tile {
+    int etat;
+    couple coord;
+} tile; 
+
+tile** tab;
+
+
+
+
+#endif /* PLATEAU_H */

regles.c

@@ -0,0 +1,139 @@
+/* Leni Boscher * Tanguy Domergue */
+
+#include<stdio.h>
+#include<stdlib.h>
+#include<graph.h>
+#include"regles.h"
+#include"plateau.h"
+
+/* Fonction qui donne la case dans laquelle le pion du joueur est */
+
+couple chercherPion(int joueur) {
+    int i;
+    int j;
+    for(i=1;i<taille+1;i++) {
+        for(j=1;j<taille+1;j++) {
+            if(tab[i][j].etat==joueur) {
+                couple pion;
+                pion.x=i;
+                pion.y=j;
+                return pion; 
+            }
+        }
+    }
+}
+
+
+/* Fonction qui retourne la case sur laquelle on a cliqué */
+couple calculIndice(int x, int y){
+    int i=1;
+    int j=1;
+    for(i=1;i<taille;i++) {
+    if ((x>=tab[i][j].coord.x)&&(x<=tab[i+1][j].coord.x)) {
+        break;
+    }
+}
+
+    for(j=1;j<taille;j++) {
+    if ((y>=tab[i][j].coord.y)&&(y<=tab[i][j+1].coord.y)) {
+        break;
+    }
+}
+
+    if((x>decalage+DIMENSIONS) || (x<decalage) || (y>decalage+DIMENSIONS) || (y<decalage)) {
+        couple indice;
+        indice.x=-1;
+        indice.y=-1;
+        return indice;
+    }
+
+couple indice;
+indice.x=i;
+indice.y=j;
+
+return indice;
+}
+
+/* Fonction de restriction de déplacement : le joueur ne peut pas se déplacer si la case visée est déjà occupée ou condamnée
+Cette fonction restreint également le placement des croix : le joueur ne peut pas placer de croix sur son adversaire ou sur une case déjà condamnée */
+
+int caseVerif(couple indice) {
+    if(indice.x == -1  || indice.y == -1) {
+        return -1;
+    }
+    if(tab[indice.x][indice.y].etat==-1){
+        return -1;
+    }
+    if (tab[indice.x][indice.y].etat==0){
+        return 1;
+    } else {
+        return 0;
+    }
+   
+} 
+
+/* Fonction de restriction de déplacement : le joueur ne peut se déplacer que sur les cases adjacentes (diagonales comprises) */
+
+int deplacAdj(couple indice, couple pion) {
+    if (((pion.x)+1 == indice.x && (pion.y)+1 == indice.y) 
+    || ((pion.x)+1 == indice.x  && (pion.y) == indice.y) 
+    || ((pion.x)+1 == indice.x &&  (pion.y)-1 == indice.y)
+    || ((pion.x) == indice.x && (pion.y)+1 == indice.y) 
+    || ((pion.x) == indice.x && (pion.y)-1 == indice.y)
+    || ((pion.x)-1 == indice.x && (pion.y)+1 == indice.y) 
+    || ((pion.x)-1 == indice.x  && (pion.y) == indice.y) 
+    || ((pion.x)-1 == indice.x &&  (pion.y)-1 == indice.y)){
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+/* Fonction qui pose une condition de victoire : si le pion du joueur 1, du joueur 2 ou de l'ordinateur
+ * est entouré de cases remplies et donc ne peut plus se déplacer, la partie se termine  */
+
+
+int winCondition(couple pion1, couple pion2) {
+    if ((tab[pion1.x+1][pion1.y+1].etat!=0)
+    && (tab[pion1.x+1][pion1.y].etat!=0)
+    && (tab[pion1.x+1][pion1.y-1].etat!=0)
+    && (tab[pion1.x][pion1.y+1].etat!=0)
+    && (tab[pion1.x][pion1.y-1].etat!=0)
+    && (tab[pion1.x-1][pion1.y+1].etat!=0)
+    && (tab[pion1.x-1][pion1.y].etat!=0)
+    && (tab[pion1.x-1][pion1.y-1].etat!=0)){
+        ChargerImage("./img/winorange.png", 110, 200, 0, 1, 746, 549);
+        winner=2;
+        return 1;
+
+    } else if ((tab[pion2.x+1][pion2.y+1].etat!=0)
+    && (tab[pion2.x+1][pion2.y].etat!=0)
+    && (tab[pion2.x+1][pion2.y-1].etat!=0)
+    && (tab[pion2.x][pion2.y+1].etat!=0)
+    && (tab[pion2.x][pion2.y-1].etat!=0)
+    && (tab[pion2.x-1][pion2.y+1].etat!=0)
+    && (tab[pion2.x-1][pion2.y].etat!=0)
+    && (tab[pion2.x-1][pion2.y-1].etat!=0)){
+        winner=1;
+        ChargerImage("./img/winbleu.png", 110, 200, 0, 0, 747, 547);
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+/* Fonction qui affiche dans le terminal, l'etat de la partie après chaque coup 
+* 1 représente le pion du joueur 1, 2 représente les croix du joueur 1
+* 3 représente le pion du joueur 2 ou de l'ordinateur, 4 représente les croix du joueur 2 ou de l'ordinateur
+* 0 représente une case vide et les -1 représentent les bordures du plateau de jeu, ou il est impossible de cliquer */
+
+void AfficherTableau() {
+    int i;
+    int j;
+    for(i=1;i<taille+1;i++) {
+        for(j=1;j<taille+1;j++) {
+        printf("%d ",tab[j][i].etat);
+    }
+    printf("\n");
+    }
+}

regles.h

@@ -0,0 +1,15 @@
+#ifndef REGLES_H
+#define REGLES_H
+#include "plateau.h"
+
+/* Tableau qui parcoure chaques cases de la grille, struct qui donne les couples de coordonnées du point haut gauche de chaque case */
+int winner;
+
+couple chercherPion(int);
+couple calculIndice(int, int);
+int caseVerif(struct couple);
+int deplacAdj(struct couple,struct couple);
+int winCondition(struct couple,struct couple);
+void AfficherTableau();
+
+#endif /* REGLES_H */