update

SAE11_2024/Makefile

@@ -0,0 +1,48 @@
+### VARIABLES ###
+ 
+CC = gcc
+CFLAGS = -Wall \
+        -ansi \
+         -pedantic
+         
+LIBS = -lgraph
+EXE = exe
+OFILES = main.o \
+         graphique.o \
+         jeu.o \
+         utilitaires.o \
+      
+ 
+### BUT PAR DEFAUT ###
+ 
+but : ${EXE}
+
+### REGLES ESSENTIELLES ###
+
+${EXE} : ${OFILES}
+	$(CC) $(CFLAGS) -o ${EXE} ${OFILES} ${LIBS} 
+
+
+main.o : graphique.h jeu.h utilitaires.h
+
+jeu.o : jeu.h utilitaires.h graphique.h 
+
+graphique.o : graphique.h
+
+utilitaires.o : utilitaires.h
+
+### REGLES OPTIONNELLES ###
+
+run : but
+	./${EXE}
+
+clean :
+	-rm -f ${OFILES} ${EXE}
+
+mrproper : clean but
+ 
+### BUTS FACTICES ###
+ 
+.PHONY : but clean mrproper
+ 
+### FIN ###

SAE11_2024/README.md

@@ -0,0 +1,59 @@
+# Jeu de Placement et de Blocage (Grille Dynamique)
+
+## **Description du projet**
+Ce programme est un jeu stratégique basé sur une grille dynamique où deux joueurs (ou un joueur contre une IA) placent des pions et des croix pour bloquer leur adversaire.
+Il intègre une interface graphique interactive, des règles simples, et une logique modulaire pour faciliter l'extension et l'amélioration.
+
+---
+
+## **Fonctionnalités principales**
+- **Menu graphique interactif** :
+  - Sélection de la taille de la grille (3x3 à 9x9).
+  - Choix entre deux modes de jeu : 1 joueur contre IA ou 2 joueurs.
+  - Bouton "Confirmer" pour valider les choix et démarrer la partie.
+  
+- **Affichage dynamique de la grille** :
+  - La grille est centrée automatiquement et s’adapte à la taille choisie.
+  - Les cellules sont bien délimitées et interactives.
+
+- **Modes de jeu** :
+  - **Mode 2 joueurs** : Deux joueurs humains jouent à tour de rôle.
+  - **Mode 1 joueur** : Le joueur affronte une IA avec des placements stratégiques.
+
+- **Conditions de fin** :
+  - Un joueur est bloqué : l’autre gagne.
+  - La grille est pleine : le joueur ayant placé le dernier pion gagne.
+
+- **Menu de fin** :
+  - Affiche le gagnant avec un message coloré.
+  - Boutons "Quitter" pour fermer le programme et "Rejouer" pour recommencer une partie.
+
+---
+
+## **Structure du projet**
+Le code est organisé en plusieurs fichiers pour assurer modularité et lisibilité :
+- **`main.c`** : Point d’entrée du programme. Initialise les ressources et orchestre les appels aux fonctions principales.
+- **`graphique.c`** :
+  - Gestion de l’interface graphique (menus, affichage de la grille, pions et croix).
+- **`jeu.c`** :
+  - Logique du jeu : alternance des tours, placement des pions et croix, gestion des conditions de fin.
+- **`utilitaires.c`** :
+  - Fonctions génériques (vérification des déplacements, détection de blocage, etc.).
+
+---
+
+## **Dépendances**
+Le programme utilise la bibliothèque graphique **`graph.h`**. Assurez-vous qu’elle est installée avant de compiler.
+
+### **Prérequis :**
+1. Un environnement Linux ou compatible avec **`graph.h`**.
+2. Un compilateur C (comme `gcc`).
+3. Assurez vous d'avoir tout les fichiers .c et .h et Makefile et tout image .png dans un seul et même dossier
+
+---
+
+## **Compilation et exécution**
+1. **Compiler le programme :**
+   make run
+	ou si vous ne souhaitez pas utiliser le Makefile même s'il est la pour simplifier :
+   gcc main.c graphique.c jeu.c utilitaires.c -o jeu -lgraph ; ./jeu

SAE11_2024/graphique.c

@@ -0,0 +1,235 @@
+#include <stdlib.h>
+#include <graph.h>
+#include "graphique.h"
+#include "jeu.h"
+
+
+/* Afficher un pion */
+void AfficherPion(int x, int y, int pion) {
+    AfficherSprite(pion, x, y);
+}
+//
+
+
+/* Afficher une croix */
+void AfficherCroix(int x, int y, int croix) {
+    AfficherSprite(croix, x, y);
+}
+
+/* Redessiner une case */
+void RedessinerCase(int caseX, int caseY, int largeur_case, int offset_x, int offset_y) {
+    int x = offset_x + caseX * largeur_case;
+    int y = offset_y + caseY * largeur_case;
+
+    ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
+    RemplirRectangle(x, y, largeur_case, largeur_case);
+    ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
+    DessinerRectangle(x, y, largeur_case, largeur_case);
+}
+
+void MenuGraphique(int *taille_grille, int *nombre_joueurs) {
+    int i;
+    couleur grisClair = CouleurParComposante(255, 255, 255);
+    couleur noir = CouleurParComposante(0, 0, 0);
+    couleur orange = CouleurParComposante(250, 143, 2);
+    couleur cyan = CouleurParComposante(2, 183, 219);
+
+    int pion_bleu, pion_orange, croix_bleu, croix_orange; /* Déclarer les variables pour les sprites*/
+
+    EffacerEcran(grisClair);
+
+    Bouton boutonsGrille[] = {
+        {150, 70, 70, 50, "3x3", noir}, {250, 70, 70, 50, "4x4", noir},
+        {350, 70, 70, 50, "5x5", noir}, {450, 70, 70, 50, "6x6", noir},
+        {550, 70, 70, 50, "7x7", noir}, {650, 70, 70, 50, "8x8", noir},
+        {750, 70, 70, 50, "9x9", noir}
+    };
+
+    Bouton bouton1J = {440, 240, 50, 50, "IA", cyan};
+    Bouton bouton2J = {520, 240, 50, 50, "2J", orange};
+    Bouton confirmer = {430, 400, 120, 50, "Confirmer?", noir};
+
+    EcrireTexte(300, 50, "Veuillez choisir la taille de la grille : ", 1);
+
+    for (i = 0; i < 7; i++) {
+        DessinerBouton(boutonsGrille[i]);
+    }
+
+    EcrireTexte(230, 200, "Voulez-vous demarrer une partie a un ou deux joueurs?", 1);
+
+    DessinerBouton(bouton1J);
+    DessinerBouton(bouton2J);
+
+    int choix_grille_precedent = -1;
+    int choix_mode_precedent = -1;
+
+    while (1) {
+        if (SourisCliquee()) {
+            SourisPosition();
+            int x = _X, y = _Y;
+
+            for (i = 0; i < 7; i++) {
+                if (EstClique(boutonsGrille[i], x, y)) {
+                    *taille_grille = i + 3;
+
+                    if (choix_grille_precedent != -1) {
+                        Bouton bouton_precedent = boutonsGrille[choix_grille_precedent];
+                        ChoisirCouleurDessin(grisClair);
+                        RemplirRectangle(bouton_precedent.x, bouton_precedent.y, bouton_precedent.largeur, bouton_precedent.hauteur);
+                        DessinerBouton(bouton_precedent);
+                    }
+
+                    ChoisirCouleurDessin(noir);
+                    RemplirRectangle(boutonsGrille[i].x, boutonsGrille[i].y, boutonsGrille[i].largeur, boutonsGrille[i].hauteur);
+                    DessinerBouton(boutonsGrille[i]);
+                    choix_grille_precedent = i;
+
+                    EcrireTexte(360, 330, "Taille de grille selectionnee", 1);
+                    break;
+                }
+            }
+
+            if (EstClique(bouton1J, x, y)) {
+                *nombre_joueurs = 1;
+
+                ChoisirCouleurDessin(grisClair);
+                RemplirRectangle(340, 350, 200, 40);
+
+                if (choix_mode_precedent == 2) {
+                    ChoisirCouleurDessin(grisClair);
+                    RemplirRectangle(bouton2J.x, bouton2J.y, bouton2J.largeur, bouton2J.hauteur);
+                    DessinerBouton(bouton2J);
+                }
+
+                ChoisirCouleurDessin(cyan);
+                RemplirRectangle(bouton1J.x, bouton1J.y, bouton1J.largeur, bouton1J.hauteur);
+                DessinerBouton(bouton1J);
+                choix_mode_precedent = 1;
+
+                EcrireTexte(360, 370, "Mode 1 joueur selectionne", 1);
+
+            } else if (EstClique(bouton2J, x, y)) {
+                *nombre_joueurs = 2;
+
+                ChoisirCouleurDessin(grisClair);
+                RemplirRectangle(340, 350, 200, 40);
+
+                if (choix_mode_precedent == 1) {
+                    ChoisirCouleurDessin(grisClair);
+                    RemplirRectangle(bouton1J.x, bouton1J.y, bouton1J.largeur, bouton1J.hauteur);
+                    DessinerBouton(bouton1J);
+                }
+
+                ChoisirCouleurDessin(orange);
+                RemplirRectangle(bouton2J.x, bouton2J.y, bouton2J.largeur, bouton2J.hauteur);
+                DessinerBouton(bouton2J);
+                choix_mode_precedent = 2;
+
+                EcrireTexte(360, 370, "Mode 2 joueur selectionne", 1);
+            }
+
+            if (*taille_grille > 0 && *nombre_joueurs > 0) {
+                DessinerBouton(confirmer);
+                if (EstClique(confirmer, x, y)) {
+                    return;
+                }
+            }
+        }
+    }
+}
+
+
+/* Fonction pour réinitialiser la grille */
+void ReinitialiserGrille(int grille[][9], int taille_grille) {
+    int i, j;
+    for (i = 0; i < taille_grille; i++) {
+        for (j = 0; j < taille_grille; j++) {
+            grille[i][j] = 0;
+        }
+    }
+}
+
+/* Menu de fin */
+void MenuFin(int gagnant, int grille[][9], int taille_grille, int pion_bleu, int pion_orange,
+   int croix_bleu, int croix_orange) {
+    int x, y;
+
+    EffacerEcran(CouleurParComposante(255, 255, 255));
+
+    /* Affichage du message de fin */
+    if (gagnant == 1) {
+        ChoisirCouleurDessin(CouleurParComposante(2, 183, 219));
+        EcrireTexte(400, 300, "Le joueur bleu a gagne !", 1);
+        ChoisirCouleurDessin(CouleurParComposante(250, 143, 2));
+        EcrireTexte(400, 350, "Le joueur orange a perdu.", 1);
+    } else if (gagnant == 2) {
+        ChoisirCouleurDessin(CouleurParComposante(250, 143, 2));
+        EcrireTexte(400, 300, "Le joueur orange a gagne !", 1);
+        ChoisirCouleurDessin(CouleurParComposante(2, 183, 219));
+        EcrireTexte(400, 350, "Le joueur bleu a perdu.", 1);
+    }
+
+    /* Définition des boutons */
+    Bouton quitter = {430, 380, 120, 40, "Quitter ?"};
+    Bouton recommencer = {410, 460, 160, 40, "Recommencer ?"};
+
+    /* Dessiner les boutons */
+    DessinerBouton(quitter);
+    DessinerBouton(recommencer);
+
+    while (1) {
+        if (SourisCliquee()) {
+            SourisPosition();
+            x = _X;
+            y = _Y;
+
+            /* Vérifier si le clic est sur le bouton "Quitter" */
+            if (EstClique(quitter, x, y)) {
+                FermerGraphique();
+                return;
+            }
+
+            /* Vérifier si le clic est sur le bouton "Recommencer" */
+            else if (EstClique(recommencer, x, y)) {
+                int taille_grille = 0;
+                int nombre_joueurs = 0;
+                debutJeu(grille, taille_grille, nombre_joueurs, pion_bleu, pion_orange, croix_bleu, croix_orange);
+                /* Réinitialiser la grille */
+                ReinitialiserGrille(grille, taille_grille);
+
+                /* Relancer le jeu */
+                debutJeu(grille, taille_grille,nombre_joueurs, pion_bleu, pion_orange, croix_bleu, croix_orange);
+                return;
+            }
+        }
+    }
+}
+
+
+
+
+
+/* Dessiner un bouton */
+void DessinerBouton(Bouton bouton) {
+    ChoisirCouleurDessin(bouton.couleurTexte);
+    DessinerRectangle(bouton.x, bouton.y, bouton.largeur, bouton.hauteur);
+    EcrireTexte(bouton.x + 10, bouton.y + bouton.hauteur / 2 + 5, bouton.texte, 1);
+}
+
+/* Vérifier si un bouton a été cliqué */
+int EstClique(Bouton bouton, int x, int y) {
+    return (x >= bouton.x && x <= bouton.x + bouton.largeur && y >= bouton.y && y <= bouton.y + bouton.hauteur);
+}
+
+/* Afficher la grille */
+void AfficherGrille(int taille_grille, int largeur_case, int offset_x, int offset_y) {
+    int i, j;
+
+    for (i = 0; i < taille_grille; i++) {
+        for (j = 0; j < taille_grille; j++) {
+            int x = offset_x + j * largeur_case;
+            int y = offset_y + i * largeur_case;
+            DessinerRectangle(x, y, largeur_case, largeur_case);
+        }
+    }
+}

SAE11_2024/graphique.h

@@ -0,0 +1,23 @@
+#ifndef GRAPHIQUE_H
+#define GRAPHIQUE_H
+
+typedef struct {
+    int x, y;
+    int largeur, hauteur;
+    char texte[20];
+    couleur couleurTexte;
+} Bouton;
+
+void AfficherPion(int x, int y, int pion);
+void AfficherCroix(int x, int y, int croix);
+void RedessinerCase(int caseX, int caseY, int largeur_case, int offset_x, int offset_y);
+void MenuGraphique(int *taille_grille, int *nombre_joueurs);
+void MenuFin(int gagnant, int grille[][9], int taille_grille, int pion_bleu, int pion_orange,
+             int croix_bleu, int croix_orange);
+void ReinitialiserGrille(int grille[][9], int taille_grille);
+void DessinerBouton(Bouton bouton);
+int EstClique(Bouton bouton, int x, int y);
+void AfficherGrille(int taille_grille, int largeur_case, int offset_x, int offset_y);
+
+
+#endif /* GRAPHIQUE_H */

SAE11_2024/jeu.c

@@ -0,0 +1,365 @@
+#include <stdlib.h>
+#include <graph.h>
+#include "jeu.h"
+#include "utilitaires.h"
+#include "graphique.h"
+
+
+void GestionJeu(int grille[][9], int taille_grille, int pion_bleu, int pion_orange, int largeur_case, int offset_x, int offset_y, int croix_bleu, int croix_orange, int nombre_joueurs) {
+	int x, y, caseX, caseY, tour = 0, etat = 0;  /* 0 = placement du pion, 1 = placement de la croix */
+	int dernierXBleu = -1, dernierYBleu = -1;
+	int dernierXOrange = -1, dernierYOrange = -1;
+
+	couleur grisClair = CouleurParComposante(255, 255, 255);
+	couleur noir = CouleurParComposante(0, 0, 0);
+	couleur bleu = CouleurParComposante(2, 183, 219);
+	couleur orange = CouleurParComposante(250, 143, 2);
+
+	int xTexte = 380, yTexte = 560, largeurTexte = 480, hauteurTexte = 25;  /* Position et taille de la zone texte*/
+
+	while (1) {
+
+    	/* Choisir la couleur du texte et afficher le texte approprié*/
+    	if (etat == 0) {  /*Placement du pion*/
+		if (tour % 2 == 1) {
+			ChoisirCouleurDessin(orange);
+			EcrireTexte(xTexte, yTexte + 20, "C'est au tour du joueur orange", 1);
+		} else {
+			ChoisirCouleurDessin(bleu);
+			EcrireTexte(xTexte, yTexte + 20, "C'est au tour du joueur bleu", 1);
+		}
+    	} else {  /* Placement de la croix*/
+		if (tour % 2 == 1) {
+			ChoisirCouleurDessin(orange);
+			EcrireTexte(xTexte, yTexte + 20, "C'est au tour du joueur orange de placer la croix", 1);
+		} else {
+			ChoisirCouleurDessin(bleu);
+			EcrireTexte(xTexte, yTexte + 20, "C'est au tour du joueur bleu de placer la croix", 1);
+		}
+	}
+
+    	/* Gestion des clics de la souris*/
+	if (SourisCliquee()) {
+		SourisPosition();
+		x = _X;
+		y = _Y;
+
+        	/* Calcul des indices de la case cliquée*/
+		caseX = (x - offset_x) / largeur_case;
+		caseY = (y - offset_y) / largeur_case;
+
+        	/* Vérification si les coordonnées de la case sont valides*/
+		if (caseX >= 0 && caseX < taille_grille && caseY >= 0 && caseY < taille_grille) {
+            	if (etat == 0) {  /*Placement du pion*/
+			int dernierX = (tour % 2 == 0) ? dernierXBleu : dernierXOrange;
+			int dernierY = (tour % 2 == 0) ? dernierYBleu : dernierYOrange;
+
+                	if (grille[caseY][caseX] == 0 &&  /* Case vide */
+                    	((dernierX == -1 && dernierY == -1) ||  /* Premier placement */
+			DeplacementValide(dernierX, dernierY, caseX, caseY))) {
+                    	/*Effacer la dernière position du pion*/
+                		if (dernierX != -1 && dernierY != -1) {
+                			grille[dernierY][dernierX] = 0;
+                			RedessinerCase(dernierX, dernierY, largeur_case, offset_x, offset_y);
+                		}
+
+                    	/* Affichage du nouveau pion*/
+                		int pion = (tour % 2 == 0) ? pion_bleu : pion_orange;
+						int ajustement_x = (taille_grille <= 4) ? -30 : 0; /* Décale les pions à droite pour une petite grille*/
+						int ajustement_y = (taille_grille <= 4) ? -30 : 0; /*Décale les pions vers le haut pour une petite grille*/
+                		int pion_x = offset_x + caseX * largeur_case + (largeur_case - 50) / 2 + ajustement_x;
+                		int pion_y = offset_y + caseY * largeur_case + (largeur_case - 50) / 2 + ajustement_y;
+                		AfficherPion(pion_x, pion_y, pion);
+
+                    	/*Mise à jour de la grille*/
+                		grille[caseY][caseX] = (tour % 2 == 0) ? 1 : 2;
+
+                    	/* Mise à jour des coordonnées du dernier pion*/
+                		if (tour % 2 == 0) {
+                			dernierXBleu = caseX;
+                			dernierYBleu = caseY;
+                		} else {
+                			dernierXOrange = caseX;
+                			dernierYOrange = caseY;
+                		}
+
+                    	etat = 1;  /* Passage à l'état de placement de la croix*/
+                	}
+            	} else if (etat == 1) {  /* Placement de la croix*/
+                	if (grille[caseY][caseX] == 0) {  /*La case est vide*/
+                    	/*  Ajout de la croix à la grille*/
+                	grille[caseY][caseX] = (tour % 2 == 0) ? 3 : 4;
+
+                    	/*Affichage de la croix*/
+                	int croix_x = offset_x + caseX * largeur_case + (largeur_case - 50) / 2;
+                	int croix_y = offset_y + caseY * largeur_case + (largeur_case - 50) / 2;
+                	int croix = (tour % 2 == 0) ? croix_bleu : croix_orange;
+                	AfficherCroix(croix_x, croix_y, croix);
+
+                    	/*Passage au prochain tour*/
+                	tour++;
+                	ChoisirCouleurDessin(grisClair);
+    					RemplirRectangle(xTexte, yTexte, largeurTexte, hauteurTexte);  /*Zone d'effacement du texte*/
+                	etat = 0;
+
+                    	/*Vérification des conditions de blocage*/
+                	if (tour >= 2) {
+                		if (EstBloque(grille, taille_grille, dernierXBleu, dernierYBleu)) {
+                			MenuFin(2, grille, taille_grille, pion_bleu, pion_orange, croix_bleu, croix_orange);
+                            	return;  /* Fin du jeu*/
+                		} else if (EstBloque(grille, taille_grille, dernierXOrange, dernierYOrange)) {
+                			MenuFin(1, grille, taille_grille, pion_bleu, pion_orange, croix_bleu, croix_orange);
+                            	return;  /*  Fin du jeu*/
+                		}
+                	}
+                }
+            }
+        }
+    }
+
+    	/* Vérification de la fin de la partie*/
+    if (EstGrillePleine(grille, taille_grille)) {
+    	int gagnant = (tour % 2 == 0) ? 2 : 1;
+    	MenuFin(gagnant, grille, taille_grille, pion_bleu, pion_orange, croix_bleu, croix_orange);
+        	return;  /* Fin du jeu*/
+    }
+}
+}
+
+
+
+
+void GestionJeuIA(int grille[][9], int taille_grille, int pion_bleu, int pion_orange, int largeur_case, int offset_x, int offset_y, int croix_bleu, int croix_orange) {
+
+int x, y, caseX, caseY, tour = 0, etat = 0;  /* 0 = placement du pion, 1 = placement de la croix */
+
+	int dernierXBleu = -1, dernierYBleu = -1;
+
+	int dernierXOrange = -1, dernierYOrange = -1;
+	int xTexte = 380, yTexte = 560, largeurTexte = 500, hauteurTexte = 25;  /* Position et taille de la zone texte*/
+	couleur grisClair = CouleurParComposante(255, 255, 255);
+	couleur noir = CouleurParComposante(0, 0, 0);
+	couleur bleu = CouleurParComposante(2, 183, 219);
+	couleur orange = CouleurParComposante(250, 143, 2);
+
+	while (1) {
+
+   	/* Choisir la couleur du texte et afficher le texte approprié*/
+    	if (etat == 0) {  /* Placement du pion*/
+		if (tour % 2 == 1) {
+			ChoisirCouleurDessin(orange);
+			EcrireTexte(xTexte, yTexte + 20, "C'est au tour du joueur orange", 1);
+		} else {
+			ChoisirCouleurDessin(bleu);
+			EcrireTexte(xTexte, yTexte + 20, "C'est au tour du joueur bleu", 1);
+		}
+    	} else {  /* Placement de la croix*/
+		if (tour % 2 == 1) {
+			ChoisirCouleurDessin(orange);
+			EcrireTexte(xTexte, yTexte + 20, "C'est au tour du joueur orange de placer la croix", 1);
+		} else {
+			ChoisirCouleurDessin(bleu);
+			EcrireTexte(xTexte, yTexte + 20, "C'est au tour du joueur bleu de placer la croix", 1);
+		}
+	}
+
+
+	if (tour % 2 == 0) {
+
+	        	/* Tour du joueur humain (bleu) */
+
+		if (SourisCliquee()) {
+
+			SourisPosition();
+
+			x = _X;
+
+			y = _Y;
+
+	            	/* Calcul des indices de la case cliquée */
+
+			caseX = (x - offset_x) / largeur_case;
+
+			caseY = (y - offset_y) / largeur_case;
+
+	            	/* Vérification si les coordonnées de la case sont valides */
+
+			if (caseX >= 0 && caseX < taille_grille && caseY >= 0 && caseY < taille_grille) {
+
+				if (etat == 0 && grille[caseY][caseX] == 0 &&
+
+					(dernierXBleu == -1 || DeplacementValide(dernierXBleu, dernierYBleu, caseX, caseY))) {
+
+	                    	/* Effacer la dernière position du pion */
+
+					if (dernierXBleu != -1 && dernierYBleu != -1) {
+
+						grille[dernierYBleu][dernierXBleu] = 0;
+
+						RedessinerCase(dernierXBleu, dernierYBleu, largeur_case, offset_x, offset_y);
+
+					}
+
+
+                    	/* Affichage du pion bleu */
+                    int ajustement_x = (taille_grille <= 4) ? -30 : 0; /* Décale les pions à droite pour une petite grille*/
+                    int ajustement_y = (taille_grille <= 4) ? -30 : 0; /* Décale les pions vers le haut pour une petite grille*/
+					int pion_x = offset_x + caseX * largeur_case + (largeur_case - 50) / 2 + ajustement_x;
+					int pion_y = offset_y + caseY * largeur_case + (largeur_case - 50) / 2 + ajustement_y;
+					AfficherPion(pion_x, pion_y, pion_bleu);
+
+	                    	/* Mise à jour de la grille */
+
+					grille[caseY][caseX] = 1;
+
+					dernierXBleu = caseX;
+
+					dernierYBleu = caseY;
+
+	                    	etat = 1;  /* Passage à l'état de placement de la croix */
+
+				} else if (etat == 1 && grille[caseY][caseX] == 0) {
+
+	                    	/* Placement de la croix */
+
+					int croix_x = offset_x + caseX * largeur_case + (largeur_case - 50) / 2;
+					int croix_y = offset_y + caseY * largeur_case + (largeur_case - 50) / 2;
+					AfficherCroix(croix_x, croix_y, croix_bleu);
+
+					grille[caseY][caseX] = 3;
+
+					tour++;
+					ChoisirCouleurDessin(grisClair);
+    					RemplirRectangle(xTexte, yTexte, largeurTexte, hauteurTexte);  /*Zone d'effacement du texte*/
+					etat = 0;
+
+				}
+
+			}
+
+		}
+
+	} else {
+
+	        	/* Tour de l'IA (orange) */
+
+		int pionX, pionY, croixX, croixY;
+
+	        	/* Placer le pion de l'IA dans une zone valide */
+
+		do {
+
+			pionX = rand() % taille_grille;
+
+			pionY = rand() % taille_grille;
+
+	            	/* Vérifier si la case est vide et si le déplacement est valide par rapport au dernier pion */
+
+		} while (grille[pionY][pionX] != 0 ||
+			(dernierXOrange != -1 && dernierYOrange != -1 && !DeplacementValide(dernierXOrange, dernierYOrange, pionX, pionY)));
+		if (dernierXOrange != -1 && dernierYOrange != -1) {
+	            	/* Effacer la dernière position du pion de l'IA */
+			grille[dernierYOrange][dernierXOrange] = 0;
+			RedessinerCase(dernierXOrange, dernierYOrange, largeur_case, offset_x, offset_y);
+		}
+
+	        	/* Affichage du pion orange */
+        	int ajustement_x = (taille_grille <= 4) ? -30 : 0; /* Décale les pions à droite pour une petite grille*/
+        	int ajustement_y = (taille_grille <= 4) ? -30 : 0; /* Décale les pions vers le haut pour une petite grille*/
+			int pion_x = offset_x + pionX * largeur_case + (largeur_case - 50) / 2 + ajustement_x;
+			int pion_y = offset_y + pionY * largeur_case + (largeur_case - 50) / 2 + ajustement_y;
+			AfficherPion(pion_x, pion_y, pion_orange);
+
+	        	/* Mise à jour de la grille */
+		grille[pionY][pionX] = 2;
+		dernierXOrange = pionX;
+		dernierYOrange = pionY;
+	        	/* Attente avant de placer la croix de l'IA */
+		Delai(500);
+
+	        	/* Placer la croix de l'IA */
+		do {
+			croixX = rand() % taille_grille;
+			croixY = rand() % taille_grille;
+	        	} while (grille[croixY][croixX] != 0 || (croixX == pionX && croixY == pionY));  /* Éviter de placer la croix sur le pion */
+
+	        	/* Affichage de la croix orange */
+			int croix_x = offset_x + croixX * largeur_case + (largeur_case - 50) / 2;
+			int croix_y = offset_y + croixY * largeur_case + (largeur_case - 50) / 2;
+			AfficherCroix(croix_x, croix_y, croix_orange);
+
+	        	/* Mise à jour de la grille */
+			grille[croixY][croixX] = 4;
+			ChoisirCouleurDessin(grisClair);
+    			RemplirRectangle(xTexte, yTexte, largeurTexte, hauteurTexte);  /* Zone d'effacement du texte*/
+			tour++;
+		}
+	    	/* Vérification des conditions de fin de jeu après chaque tour */
+		if (tour >= 2) {
+			if (EstBloque(grille, taille_grille, dernierXBleu, dernierYBleu)) {
+						MenuFin(2, grille, taille_grille, pion_bleu, pion_orange, croix_bleu, croix_orange);  /* Fin du jeu, l'IA a gagné */
+				return;
+			} else if (EstBloque(grille, taille_grille, dernierXOrange, dernierYOrange)) {
+						MenuFin(1, grille, taille_grille, pion_bleu, pion_orange, croix_bleu, croix_orange);  /* Fin du jeu, le joueur humain a gagné */
+				return;
+			}
+		}
+	    	/* Vérification de la fin de la partie si la grille est pleine */
+		if (EstGrillePleine(grille, taille_grille)) {
+	        	int gagnant = (tour % 2 == 0) ? 2 : 1;  /* L'IA ou le joueur humain a gagné */
+				MenuFin(gagnant, grille, taille_grille, pion_bleu, pion_orange, croix_bleu, croix_orange);  /* Fin du jeu */
+	        	return;  /* Fin du jeu */
+
+		}
+
+	}
+
+}
+
+
+
+void debutJeu(int grille[][9], int taille_grille, int nombre_joueurs, int pion_bleu, int pion_orange, int croix_bleu, int croix_orange) {
+	couleur grisClair = CouleurParComposante(255, 255, 255);
+
+	/* Afficher le menu graphique pour la sélection */
+	MenuGraphique(&taille_grille, &nombre_joueurs);
+
+	/* Si les valeurs sont correctement définies, démarrer la partie */
+	if (taille_grille > 0 && nombre_joueurs > 0) {
+		int largeur_case = 500 / taille_grille; /* Calcul de la largeur d'une case */
+		int offset_x = (1000 - taille_grille * largeur_case) / 2;
+		int offset_y = (600 - taille_grille * largeur_case) / 2;
+		if (taille_grille <= 4) {
+			pion_bleu = ChargerSprite("Pionb_100x100.png");
+			pion_orange = ChargerSprite("Pionc_100x100.png");
+		} else {
+			pion_bleu = ChargerSprite("Pionb_50x50.png");
+			pion_orange = ChargerSprite("Pionc_50x50.png");
+		}
+
+		EffacerEcran(CouleurParComposante(255,255,255));
+		AfficherGrille(taille_grille, largeur_case, offset_x, offset_y);
+		ReinitialiserGrille(grille, taille_grille); 
+
+
+		/* Lancer la gestion du jeu */
+
+		if (nombre_joueurs == 1) {
+			GestionJeuIA(grille, taille_grille, pion_bleu, pion_orange, largeur_case, offset_x, offset_y, croix_bleu, croix_orange);
+			LibererSprite(pion_bleu);
+    		LibererSprite(pion_orange);
+    		LibererSprite(croix_bleu);
+    		LibererSprite(croix_orange);
+		} else {
+			GestionJeu(grille, taille_grille, pion_bleu, pion_orange, largeur_case, offset_x, offset_y, croix_bleu, croix_orange, nombre_joueurs);
+			LibererSprite(pion_bleu);
+    		LibererSprite(pion_orange);
+    		LibererSprite(croix_bleu);
+    		LibererSprite(croix_orange);
+
+		}
+
+	}
+}
+
+

SAE11_2024/jeu.h

@@ -0,0 +1,13 @@
+#ifndef JEU_H
+#define JEU_H
+
+/* Déclarations des fonctions */
+void GestionJeu(int grille[][9], int taille_grille, int pion_bleu, int pion_orange,
+                int largeur_case, int offset_x, int offset_y, int croix_bleu, int croix_orange, int nombre_joueurs);
+
+void GestionJeuIA(int grille[][9], int taille_grille, int pion_bleu, int pion_orange,
+                  int largeur_case, int offset_x, int offset_y, int croix_bleu, int croix_orange);
+
+void debutJeu(int grille[][9], int taille_grille, int nombre_joueurs, int pion_bleu, int pion_orange, 
+int croix_bleu, int croix_orange);
+#endif /* JEU_H */

SAE11_2024/main.c

@@ -0,0 +1,35 @@
+#include <time.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <graph.h>
+
+#include "graphique.h"
+#include "jeu.h"
+#include "utilitaires.h"
+
+int main() {
+    InitialiserGraphique();
+    CreerFenetre(10, 10, 1000, 600);
+
+    couleur grisClair = CouleurParComposante(255, 255, 255);
+    EffacerEcran(grisClair);
+
+    int pion_bleu = ChargerSprite("Pionb_50x50.png");
+    int pion_orange = ChargerSprite("Pionc_50x50.png");
+    int croix_bleu = ChargerSprite("croixb4x4.png");
+    int croix_orange = ChargerSprite("croixo4x4.png");
+    int taille_grille = 0, nombre_joueurs = 0;
+    int grille[9][9] = {0};
+
+    /* Démarrage du jeu */
+    debutJeu(grille,taille_grille,nombre_joueurs,pion_bleu,pion_orange,croix_bleu,croix_orange);
+
+    /* Libérer les ressources avant de fermer */
+    LibererSprite(pion_bleu);
+    LibererSprite(pion_orange);
+    LibererSprite(croix_bleu);
+    LibererSprite(croix_orange);
+    Touche();
+    FermerGraphique();
+    return EXIT_SUCCESS;
+}

SAE11_2024/utilitaires.c

@@ -0,0 +1,79 @@
+#include <stdlib.h>
+#include <graph.h>
+#include <time.h>
+#include "utilitaires.h"
+#include "jeu.h"
+#include "graphique.h"
+
+
+void Delai(int duree_ms) {
+
+/* La duree est en millisecondes. Le principe est d'effectuer une boucle vide. */
+
+long fin = clock() + duree_ms * CLOCKS_PER_SEC / 1000;  /* Convertir la duree en unites de clock() */
+
+	while (clock() < fin) {
+
+    	/* Rien à faire ici, juste attendre */
+
+	}
+
+}
+
+int EstBloque(int grille[][9], int taille_grille, int caseX, int caseY) {
+	int i;
+	int directions[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};
+
+	for (i = 0; i < 8; i++) {
+
+		int dirX = caseX + directions[i][0];
+
+		int dirY = caseY + directions[i][1];
+
+		if (dirX >= 0 && dirX < taille_grille && dirY >= 0 && dirY < taille_grille) {
+
+			if (grille[dirY][dirX] == 0) {
+
+				return 0;
+
+			}
+
+		}
+
+	}
+
+	return 1;
+
+}
+
+
+
+
+int EstGrillePleine(int grille[][9], int taille_grille) {
+	int i,j;
+	for ( i = 0; i < taille_grille; i++) {
+
+		for (j = 0; j < taille_grille; j++) {
+
+    	if (grille[i][j] == 0) { 
+    	/* Si une case est vide, la grille n'est pas pleine */
+
+			return 0;
+
+		}
+
+	}
+
+}
+
+return 1; /* La grille est pleine */
+
+}
+
+/* Fonction pour verifier si le deplacement est valide (pas plus de 1 case) */
+
+int DeplacementValide(int caseXActuelle, int caseYActuelle, int caseXCible, int caseYCible) {
+
+	return (abs(caseXActuelle - caseXCible) <= 1) && (abs(caseYActuelle - caseYCible) <= 1);
+
+}

SAE11_2024/utilitaires.h

@@ -0,0 +1,8 @@
+#ifndef UTILITAIRES_H
+#define UTILITAIRES_H
+
+void Delai(int duree_ms);
+int EstBloque(int grille[][9], int taille_grille, int caseX, int caseY);
+int EstGrillePleine(int grille[][9], int taille_grille);
+int DeplacementValide(int caseXActuelle, int caseYActuelle, int caseXCible, int caseYCible);
+#endif /*UTILITAIRES_H*/