Upload files to "/"

DEV-R3.03/srivastava_5.txt

@@ -0,0 +1,123 @@
+- Q1-a:
+- Demande : Je veux un chatbot d'IA sur le RGPD et l'AI act afin d'être tranquille niveau conformité 
+	- Besoin A: Je dois pouvoir discuter avec une IA sur les différents droits et régulations informatique 
+	- Besoin B: Je dois pouvoir être tranquille niveau conformité sur le RGPD et l'AI act
+	- Besoin C: Je dois pouvoir recevoir des informations qui sont dans la base documentaire interne
+
+- Q1-b:
+- Questions ouvertes : 
+	1. Pourriez-vous me décrire une journée type de travail où vous auriez besoin d'informations juridique informatique ?
+	2. Qu'est-ce qui vous frustre le plus lorsque vous avez besoin d'utiliser la base documentaire interne ?
+	3. Si le chatbot IA était là et était fonctionnel, que lui demanderiez-vous ?
+	4. Décrivez moi les défis que vous rencontrez au niveau conformité au quotidien.
+
+- Q1-c: 
+	- Mauvaises question 1: Voulez-vous le modèle d'IA GPT4o ou GPT-5 ?
+	- Mauvaises question 2: Donc faut-il que le chatbot IA puisse donner un tableau de type tableur pour tout ce qui est RGPD ?
+	- Car: Elles sont problématique car souvent c'est au développeur de penser à comment répondre à ce genre de question, et que le client n'est pas un client trop technique qui a un besoin et qui veut une solution. 
+
+- Q2-a:
+	- E1: EF, Il décrit ce que le chatbot doit faire, son comportement face à un langage naturel et son action de renvoyer une réponse textuelle.
+	- E2: ENF, Il décrit ici comment est-ce que le chatbot doit répondre donc avec une contrainte de temps et une contrainte de connexion.
+	- E3: EF, Il décrit ce que le chatbot doit faire avec les données personnelles identifiable des employés, qui est de ne pas les envoyés à de API d'IA externes.
+	- E4: ENF, Il décirt comment le chatbot doit se comporter vis-à-vis des journaux de conversation contenant des données personnelles.
+	- E5: EF, Il décrit ce que le chatbot doit faire, il n'y a aucune précision sur comment mais il veut qu'il soit intelligent et toujours donner des réponses de haute qualité.
+	- E6: EF, Il décrit ce que le chatbot doit faire donc brièvement sans détail, que faire lorsque la question dépasse son périmètre, qui est d'escalader la demande vers une autre équipe.
+
+- Q2-b:
+	- ENF-reformulée-1: Le chatbot doit maintenir un taux d'hallucination inférieur à 10%
+	- ENF-reformulée-2: le chatbot doit atteindre un score de satisfaction moyen de 4/5
+
+- Q2-c:
+	Pour E3: envoyer des données vers une API externe fait sortir l'information du périmètre sécurisé de l'entreprise. Cela expose les secrets et les données critique à un tiers, violant le principe de confidentialité requis pour la conformité.
+	Pour E4: Une ocnversation illimitée permettrait de "profiter" ou surveiller les employés sur le long terme. La limitation de 30 jours et l'anonymisation qui garanti le droit à l'oubli et empêche l'outil de devenir un outil de surveillance intrusive.
+
+- Q3-a:
+	- US1: S, E, T ne sont pas respectés
+		- S: "chatbot complet" est bien trop gros pour une seule story, c'est le projet en entier.
+		- E: Impossible d'estimer la charge de travail sur un pérmiètre aussi vague "complet"
+		- T: "Conforme au RGPD" est un audit juridique pas un test binaire simple...
+
+	- US2: T, E, I ne sont pas respectés
+		- T: "Aimer utiliser" est une émotion subjective, impossible à tester.
+		- E: les adjectifs "moderne et intuitive" sont trop flous pour estimer le temps de développement.
+		- I: L'interface dépend entièrement des fonctionnalités backend qui seront développées.
+	
+	- US3: N, V, I ne sont pas respectés
+		- N: la user story impose la solution technique ("API SuperLM-9000") au lieu de décrire le besoin, fermant la discussion.
+		- V: C'est une tâche technique ("Conencter l'API"). La valeur pour n'est pas claire.
+		- I: Elle crée une dépendance forte et immédiate à un fournisseur spécifique.
+
+	- US4: S, E, T ne sont pas respectés
+		- S: "Tous les droits" (accès rectification, oubli, portabilité...) est une Epic géante, pas une story.
+		- E: Trop large pour être chiffré dans un sprint.
+		- T: On ne peut pas écrire un test unique pour "gérer tous les droits" en même temps.
+
+- Q3-b nouveau backlog (8 user stories INVEST):
+- Transparence : 
+	- US-A: En tant qu'utilisateur, je veux voir une mention explicite "Réponse générée par IA" sous chaque message afin de ne pas confondre le chatbot avec un interlocuteur humain RH.
+	- US-B: En tant qu'utilisateur, je veux que le chatbot affiche les liens vers les documents internes (sources) utilisés pour construire sa réponse afin de pouvoir vérifier l'exactitude de l'information par moi-même.
+
+- Droit des personnes : 
+	- US-C: En tant qu'employé, je veux pouvoir télécharger un export PDF de mes conversations afin d'exercer mon droit d'accès et de portabilité des données.
+	- US-D: En tant qu'employé, je  veux un bouton "Effacer mes données" qui supprime l'historique de la session courante afin d'exercer mon droit à l'effacement concernant des questions sensibles
+
+- Epic: 
+	- US-E: En tant que DPO, je veux une interface d'administration complète pour gérer les audits de logs, les alertes de sécurité et les demandes de droits complexes afin de garantir la conformité légale globale de l'outil.
+
+- Autres (Fonctionnel/Qualité):
+	- US-F: En tant qu'utilisateur, je veux poser des questions en language naturel sur le RGPD afin d'obtenir une réponse immédiate sans avoir à lire les textes juridiques bruts.
+	- US-G: En tant qu'expert métier, je veux pouvoir signaler une réponse incorrecte afin d'aider l'équipe technique àcorriger les hallucinations du modèle.
+	- US-H: En tant qu'admin Sécurité, je veux que le système masque automatiquement les numéros de sécurité sociale détectés dans les prompts afin d'empêcher leur stockage en clair dans les bases de données.
+
+- Q3-c: 
+	- Je choisi les user stories US-B et US-D:
+	US-B: 
+		- Critère 1. scénario nominal: lorsque le chatbot répond à une question sur le "télétravail", la réponse doit se terminer par une section "Sources:" contenant au moins un lien cliquable vers le document intranet pertinent.
+		- Critère 2. cas d'erreur/manque de source: Si la question de l'utilisateur ne correspond à aucun document de la base de connaissance, le chatbot doit répondre "je ne trouve pas cette information dans la basedocumentaire interne" et ne pas inventer une réponse
+		- Critère 3. La confidentialité: Si le document source identifié possède un tag de sécurité "Confidentiel - CODIR", le chatbot ne doit pas l'utiliser pour générer la réponse ni afficher le lien si l'utilisateur n'a pas les droits d'accès correspondants.
+
+	US-C:
+		- Critère 1. Scénario nominal: Après avoir cliqué sur le bouton "Effacer l'historique", l'interface utilisateur se vide et une requête en base de données confirme que les logs textuels associés à cet ID de session ont été supprimés physiquement.
+		- Critère 2. Cas d'erreur: Si le service de base de données est indisponible au moment de la demande, le système doit afficher un message d'erreur explicite "Suppression impossible pour le moment, veuillez réessayer",plutôt que de laisser l'utilisateur crorie que ses données sont effacés.
+		- Critère 3. Confidentialité/Sensible: La suppression de la conversation doit également faire en sorte à ce que l'on évite que des fragments de données sensibles ne ressortent lors de recherches futures.
+
+- Q4-a: 
+	- Acteur primaire: Employé (Utilisateur authentifié) 
+	- Précondition principale: L'utilisateur est connecté et possède un historique de conversations enregistré dans le système
+	- Postcondition de succès: Les logs de conversations sont supprimés de l'interface et anonymisés/effacés en base de données.
+	- Postcondition d'échec: Les données sont conservées intactes et un message d'erreur informe l'utilisateur de l'échec de l'opération
+
+- Q4-b scénario nominal:
+	1. Acteur: L'employé clique sur le bouton ou tape la commande "Gérer mes données personnelles" dans l'interface du chatbot.
+	2. Système: Affiche un menu d'options liées aux droits RGPD (Accès, Rectification, Effacement)
+	3. Acteur: L'employé séléctionne l'option "Effacer l'historique de mes conversations" 
+	4. Système: Demande une confirmation explicite: "Attention, cette action est irréversible. Confirmez-vous la suppression ?"
+	5. Acteur: L'employé appuie sur "Confirmer" 
+	6. Système: Lance le processus de suppression en arrière-plan et purge les données de la session.
+	7. Système: Affiche une notification desuccès: "Votre historique avec succès" et réinitialise la fenêtre de chat.
+
+- Q4-c: 
+	- Scénario A: Si, au moment de valider la suppression, la session de l'utilisateur a expiré, le système interrompt le processus, affiche un message "Session expiré" et redirige l'utilisateur vers la page de connexion. Les données ne sont pas effacées.
+
+    - Scénario B: Si le système détecte qu'une conversation contient des éléments liés à une enquête de harcèlement en cours, le Système procède à une suppression logique pour l'utilisateur mais archive les logs dans un coffre-fort sécurisé pour le service juridique. Le système informe alors l'utilisateur : "Vos conversations ont été retirées de votre historique visible.
+
+Q5-a:
+Voici les classes conceptuelles identifiées pour la gestion des conversations et des droits :
+    - Utilisateur : (Attributs : ID_Employé, Nom, Email, Rôle).
+    - Conversation : (Attributs : ID_Session, Date_Début, Statut_Escalade).
+    - Message : (Attributs : Contenu_Texte, Horodatage, Emetteur, Est_Hallucination).
+    - DemandeDroit : (Attributs : Type_Droit [Accès/Effacement], Date_Demande, Statut_Traitement).
+    - CelluleConformité : (Attributs : ID_Service, Nom_Responsable).
+    - Association clé : Utilisateur (1) ----- (0..*) Conversation (Un utilisateur peut avoir plusieurs conversations, une conversation appartient à un seul utilisateur).
+
+Q5-b:
+Ce processus décrit le flux lorsqu'une question dépasse les compétences de l'IA :
+    - Utilisateur : Pose une question complexe (ex: "Quels sont les impacts de l'AI Act sur nos filiales hors UE ?").
+    - Chatbot : Analyse la question, détecte un score de confiance faible et un sujet sensible ("AI Act / International").
+    - Chatbot : Répond à l'utilisateur : "Cette question nécessite une expertise juridique approfondie. Je transmets votre demande à la cellule conformité."
+    - Système : Crée un ticket d'escalade et notifie la CelluleConformité.
+    - Juriste RGPD : Reçoit la notification, analyse la question et consulte les textes de loi.
+    - Juriste RGPD : Rédige une réponse validée juridiquement dans l'interface d'administration.
+    - Système : Envoie la réponse du juriste dans le fil de discussion du chatbot.
+    - Utilisateur : Reçoit la notification et lit la réponse qualifiée.

DEV.3.2/TP/TP3-Listes/1.Luminance/Dessin.java

@@ -0,0 +1,10 @@
+public class Dessin extends JPanel {
+	public Dessin() {
+
+	}
+
+	@Override
+	public void paintComponent(Graphics g) {
+	
+	}
+}

DEV.3.2/TP/TP3-Listes/1.Luminance/Fenetre.java

@@ -0,0 +1,23 @@
+import java.awt.*;
+import javax.swing.*;
+
+public class Fenetre extends JFrame {
+
+	public Fenetre() {
+		super("Luminance");
+
+		this.setSize(300, 100);
+		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		this.setLocationRelativeTo(null);
+		this.setLayout(new GridBagLayout());
+		this.setBackgrund(Color.WHITE);
+		GridBagConstraints contraintes = new GridBagConstraints();
+
+		contraintes.gridx = 1;
+		contraintes.gridy = 1;
+		
+		
+		this.setVisible(true);
+
+	}
+}

DEV.3.2/TP/TP3-Listes/1.Luminance/Luminance.java

@@ -0,0 +1,11 @@
+import java.util.ArrayList;
+
+public class Luminance {
+
+	private ArrayList<Color> couleurs;
+	private List listeDePolygones;
+
+	public Luminance() {
+
+	}
+}

DEV.3.2/TP/TP3-Listes/1.Luminance/Main.java

@@ -0,0 +1,6 @@
+public class Main {
+	public static void main(String[] args) {
+		Fenetre fenetre = new Fenetre();
+		fenetre.setVisible(true);
+	}
+}

DEV.3.2/cours/3.Listes.md

@@ -15,7 +15,7 @@ Mini conclusion : les listes c'est mauvais on sait pas ce que ça donne et gén
 L'interface [Collection](https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html) représente les collections en général. Elle hérite de l'interface [Iterable](https://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html), ce qui la rend compatible avec les boucles énumératives. L'interface [List](https://docs.oracle.com/javase/8/docs/api/java/util/List.html) hérite de Collection et représente une liste.
 Il y a aussi [Iterator](https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html) avec ses méthode : 
 * boolean hasNext : Returns `true` if the iteration has more elements.
-* [E](https://docs.oracle.com/javase/8/docs/api/java/util/List.html "type parameter in List")[remove](https://docs.oracle.com/javase/8/docs/api/java/util/List.html#remove-int-)(int index) Removes the element at the specified position in this list (optional operation).
+* [E](https://docs.oracle.com/javase/8/docs/api/java/util/List.html "type parameter in List") [remove](https://docs.oracle.com/javase/8/docs/api/java/util/List.html#remove-int-)(int index) Removes the element at the specified position in this list (optional operation).
 * [add](https://docs.oracle.com/javase/8/docs/api/java/util/List.html#add-int-E-)(int index, [E](https://docs.oracle.com/javase/8/docs/api/java/util/List.html "type parameter in List") element)Inserts the specified element at the specified position in this list (optional operation).
 Parmi les classes qui réalisent List, on note [ArrayList](https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html) et [LinkedList](https://docs.oracle.com/javase/8/docs/api/java/util/LinkedList.html) 
 

DEV.3.2/cours/4.Piles.md

@@ -0,0 +1,23 @@
+## Principe
+
+Une pile est une structure de données abstraite (une boîte noir) qui supporte les opérations suivantes : 
+* *push* : ajoute un élément à la pile élément par élément
+* *pop* : retire un élément de la pile et renvoie l'élément le plus récent :
+* *empty* : détermine si la pile est vide
+
+L'historique navigateur est une pile qui a été augmenté. Le bouton back est une opération utilisé ave la partie pile. Stocker les actions utilisateurs avec une pile.
+
+Une pile peut servir pour un retour arrière, pour simuler une récursivité. 
+
+## En java
+"La classe *stack* est vraiment merdissime" s'exclama Luc... 
+L'interface *Deque* représente une pile (entre autres).
+		push -> addLast (version simple : offer)
+		pop -> removeLast (version simple : poll)
+		empty -> isEmpty (null)
+
+Cette interface est réalisée par *ArrayDeque* et *LinkedList*.
+
+# A monter soi même
+Une pile peut être codée avec une liste chainée. On range les éléments du plus récent au plus ancien afin de toujours travailler au début.
+Une pile peut être codée également avec un tableau. Les éléments sont ordonnés du plus ancien au plus récent. On peut gérer les problèmes de capacité en limitant la pile ou en redimensionnant le tableau.

README.md

@@ -1,6 +1,6 @@
 # DEV Repository
 
-Ce dépôt contient tous mes cours, TP, et contrôles machines réalisés dans le cadre de mon BUT Informatique. Les fichiers sont organisés par modules et par thématiques, comme suit :
+Ce dépôt contient tous mes cours, TP, contrôles machines, et SAé réalisés dans le cadre de mon BUT Informatique. Les fichiers sont organisés par modules et par thématiques, comme suit :
 
 ## Structure du dépôt
 
@@ -22,4 +22,5 @@ Ce dépôt contient tous mes cours, TP, et contrôles machines réalisés dans l
 
 ## Auteur
 
-Ce dépôt a été créé par Emmanuel SRIVASTAVA-TIAMZON dans le cadre du BUT Informatique.
+Ce dépôt a été créé par Emmanuel SRIVASTAVA-TIAMZON dans le cadre du BUT Informatique.
+Certaine SAé ont été faite avec la collaboration de Wael ATIK.

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