ajout d'un Makefile (non fonctionnel) + différents tests

Makefile

@@ -0,0 +1,39 @@
+Snake : main.o jeu.o grille.o menu.o obstacle.o pomme.o serpent.o timer.o
+	gcc -ansi -pedantic -lgraph -o Snake ../src/main.c ../src/jeu.c ../src/grille.c ../src/menu.c ../src/obstacle.c ../src/pomme.c ../src/serpent.c ../src/timer.c
+
+main.o : ../src/main.c ../include/menu.h ../include/jeu.h
+
+	gcc -ansi -pedantic -lgraph ../src/main.c
+
+jeu.o : ../src/jeu.c ../include/grille.h ../include/serpent.h ../include/pomme.h ../include/jeu.h ../include/menu.h ../include/timer.h ../include/obstacle.h
+
+	gcc -ansi -pedantic -lgraph ../src/jeu.c
+
+grille.o : ../src/grille.c ../include/grille.h
+
+	gcc -ansi -pedantic -lgraph ../src/grille.c
+
+menu.o : ../src/menu.c ../include/menu.h ../include/main.h
+
+	gcc -ansi -pedantic -lgraph ../src/menu.c
+
+obstacle.o : ../src/obstacle.c ../include/grille.h ../include/serpent.h ../include/obstacle.h ../include/pomme.h
+
+	gcc -ansi -pedantic -lgraph ../src/obstacle.c
+
+pomme.o : ../src/pomme.c ../include/grille.h ../include/serpent.h
+
+	gcc -ansi -pedantic -lgraph ../src/pomme.c
+
+serpent.o : ../src/serpent.c ../include/serpent.h ../include/main.h ../include/timer.h
+
+	gcc -ansi -pedantic -lgraph ../src/serpent.c
+
+timer.o : ../src/timer.c ../include/timer.h
+
+	gcc -ansi -pedantic -lgraph ../src/timer.c
+
+clean : 
+	-rm -f main.o jeu.o grille.o menu.o obstacle.o pomme.o serpent.o timer.o
+
+.phony : clean

make_test/Makefile

@@ -0,0 +1,39 @@
+Snake : jeu.o main.o grille.o menu.o obstacle.o pomme.o serpent.o timer.o
+	gcc -ansi -pedantic -lgraph -o Snake main.o jeu.o grille.o menu.o obstacle.o pomme.o serpent.o timer.o
+
+jeu.o : jeu.c grille.h serpent.h pomme.h jeu.h menu.h timer.h obstacle.h
+
+	gcc -ansi -pedantic -lgraph jeu.c
+
+main.o : main.c main.h menu.h jeu.h
+
+	gcc -ansi -pedantic -lgraph main.c
+
+grille.o : grille.c grille.h
+
+	gcc -ansi -pedantic -lgraph grille.c
+
+menu.o : menu.c menu.h main.h
+
+	gcc -ansi -pedantic -lgraph menu.c
+
+obstacle.o : obstacle.c grille.h serpent.h obstacle.h pomme.h
+
+	gcc -ansi -pedantic -lgraph obstacle.c
+
+pomme.o : pomme.c grille.h serpent.h
+
+	gcc -ansi -pedantic -lgraph pomme.c
+
+serpent.o : serpent.c serpent.h main.h timer.h
+
+	gcc -ansi -pedantic -lgraph serpent.c
+
+timer.o : timer.c timer.h
+
+	gcc -ansi -pedantic -lgraph timer.c
+
+clean : 
+	-rm -f main.o jeu.o grille.o menu.o obstacle.o pomme.o serpent.o timer.o
+
+.phony : clean

make_test/grille.c

@@ -0,0 +1,23 @@
+#include <graph.h>
+#include "grille.h"
+
+
+void dessinerGrille(void) {
+    /* Dessine une grille de 60 colonnes sur 40 lignes */
+    int i, j;
+    int tailleCase = 20; /* Taille d'une case */
+    couleur couleur1 = CouleurParComposante(170, 215, 82); /* Vert clair */
+    couleur couleur2 = CouleurParComposante(180, 220, 90);    /* Vert foncé */
+    ChargerImageFond("bas_grille.png"); /*Affiche l'image du bas =>  Score... Timer...*/
+
+    for (i = 0; i < 40; i++) {
+        for (j = 0; j < 60; j++) {
+            /* Alterner les couleurs en fonction de la case (1 case sur deux...) */
+            couleur couleurCase = (i + j) % 2 == 0 ? couleur1 : couleur2;
+
+            /* Dessiner la case */
+            ChoisirCouleurDessin(couleurCase);
+            RemplirRectangle(j * tailleCase, i * tailleCase, tailleCase, tailleCase);
+        }
+    }
+}

make_test/grille.h

@@ -0,0 +1,10 @@
+#ifndef GRILLE_H
+#define GRILLE_H
+
+#define TAILLE_CASE 20
+#define LARGEUR_GRILLE 60
+#define HAUTEUR_GRILLE 40
+
+void dessinerGrille(void);
+
+#endif /*GRILLE_H*/

make_test/jeu.c

@@ -0,0 +1,273 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <graph.h>
+#include "../include/grille.h"
+#include "../include/serpent.h"
+#include "../include/pomme.h"
+#include "../include/jeu.h"
+#include "../include/menu.h"
+#include "../include/timer.h"
+#include "../include/obstacle.h"
+
+
+void afficherScore(int score) {
+    char scoreStr[20];
+    /* Efface l'ancien score */
+    ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
+    RemplirRectangle(178, 946, 130, 40);
+    /* Convertit le score en chaîne de caractères */
+    snprintf(scoreStr, sizeof(scoreStr), "%d", score);
+    /* Affiche le nouveau score */
+    ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
+    EcrireTexte(179, 976, scoreStr, 2);
+}
+
+
+void lancer_jeu1(void) {
+    int fin = 1;
+    Segment serpent[100];
+    int longueur = 10;
+    int direction_x = 1;
+    int direction_y = 0;
+    int score = 0;
+    char scoreStr[20];
+    Pomme pomme;
+    int min, sec;
+
+
+    initialiser_timer(&min, &sec);
+    initialiserSerpent(serpent, &longueur);
+    dessinerGrille();
+
+    pomme = creerPomme();
+    dessinerPomme(pomme);
+
+    while (fin == 1) {
+        update_timer(&min, &sec);
+        gestionDeplacements(serpent, &direction_x, &direction_y);
+        mettreAJourSerpent(serpent, &longueur, &direction_x, &direction_y);
+
+        if (serpent[0].x == pomme.x && serpent[0].y == pomme.y) {
+            longueur++;
+            score += 5;
+            pomme = creerPomme();
+            dessinerPomme(pomme);
+        }
+
+        if (tuerSerpent(serpent, longueur)) {
+            int choixGameOver;
+            afficherMenuGameOver();
+            afficher_seconde(sec);
+            afficher_minute(min);
+            afficherScore(score);
+            /* Attend le choix du joueur après le game over */
+            choixGameOver = attendreChoixGameOver();
+        }
+
+        dessinerSerpent(serpent, &longueur);
+        afficherScore(score);
+        update_timer(&min, &sec);
+
+        attendreSerpent(150000);
+    }
+}
+
+
+void lancer_jeu2(void) {
+    int i;
+    Segment serpent[100];
+    int longueur = 10;
+    int direction_x = 1;
+    int direction_y = 0;
+    unsigned long int vitesse = 200000;  /*vitesse de base*/
+    int score = 0;
+    char scoreStr[20];
+    Pomme pommes[5];
+    int min, sec;
+
+
+    initialiser_timer(&min, &sec);
+    initialiserSerpent(serpent, &longueur);
+    dessinerGrille();
+
+    for (i = 0; i < 5; i++) {
+        pommes[i] = creerPomme();
+        dessinerPomme(pommes[i]);
+    }
+
+    while (1) {
+        gestionDeplacements(serpent, &direction_x, &direction_y);
+        mettreAJourSerpent(serpent, &longueur, &direction_x, &direction_y);
+
+        for (i = 0; i < 5; i++) {
+            if (serpent[0].x == pommes[i].x && serpent[0].y == pommes[i].y) {
+                longueur++;
+                score += 5;
+                pommes[i] = creerPomme();
+                dessinerPomme(pommes[i]);
+            }
+        }
+
+        if (tuerSerpent(serpent, longueur)) {
+            int choixGameOver;
+            afficherMenuGameOver();
+            afficher_seconde(sec);
+            afficher_minute(min);
+            afficherScore(score);
+
+            /* Attend le choix du joueur après le game over */
+            choixGameOver = attendreChoixGameOver();
+        }
+
+        dessinerSerpent(serpent, &longueur);
+
+        afficherScore(score);
+        update_timer(&min, &sec);
+
+        attendreSerpent(vitesse); /*Gère la vitesse*/
+    }
+}
+
+
+void lancer_jeu4(void) {
+    int longueur = 10;
+    int direction_x = 1;
+    int direction_y = 0;
+    int score = 0;
+    unsigned long int vitesse = 300000;  /*vitesse de base*/
+    char scoreStr[20];
+    Pomme pomme;
+    Segment serpent[100];
+    int min, sec;
+
+
+    initialiser_timer(&min, &sec);
+    initialiserSerpent(serpent, &longueur);
+    dessinerGrille();
+
+    pomme = creerPomme();
+    dessinerPomme(pomme);
+
+    while (1) {
+        gestionDeplacements(serpent, &direction_x, &direction_y);
+        mettreAJourSerpent(serpent, &longueur, &direction_x, &direction_y);
+
+        if (serpent[0].x == pomme.x && serpent[0].y == pomme.y) {
+            longueur++;
+            score += 5;
+            pomme = creerPomme();
+            dessinerPomme(pomme);
+
+            /* Augmenter la vitesse à chaque pomme mangée*/
+            vitesse -= 5000;  /* Réduire la durée d'attente (augmenter la vitesse)*/
+        }
+
+        if (tuerSerpent(serpent, longueur)) {
+            int choixGameOver;
+            afficherMenuGameOver();
+            afficherScore(score);
+            afficher_minute(min);
+            afficher_seconde(sec);
+
+            /* Attend le choix du joueur après le game over */
+            choixGameOver = attendreChoixGameOver();
+        }
+
+        dessinerSerpent(serpent, &longueur);
+        afficherScore(score);
+        update_timer(&min, &sec);
+
+        attendreSerpent(vitesse);
+    }
+}
+
+void lancer_jeu3(void) {
+    int i,j;
+    int longueur = 10;
+    int direction_x = 1;
+    int direction_y = 0;
+    int score = 0;
+    unsigned long int vitesse = 100000;  
+    char scoreStr[20];
+    Pomme pomme;
+    int nombreObstacles = 10;
+    Obstacle *obstacles = malloc(nombreObstacles * sizeof(Obstacle));
+    Segment serpent[100];
+    int min, sec;
+
+    initialiser_timer(&min, &sec);
+    initialiserSerpent(serpent, &longueur);
+    dessinerGrille();
+
+    pomme = creerPomme();
+    dessinerPomme(pomme);
+
+    placerObstacle(obstacles, nombreObstacles, LARGEUR_GRILLE, HAUTEUR_GRILLE);
+
+    while (1) {
+    gestionDeplacements(serpent, &direction_x, &direction_y);
+    mettreAJourSerpent(serpent, &longueur, &direction_x, &direction_y);
+
+    if (serpent[0].x == pomme.x && serpent[0].y == pomme.y) {
+        longueur++;
+        score += 5;
+        pomme = creerPomme();
+        dessinerPomme(pomme);
+
+        
+        vitesse -= 5000;
+    }
+
+    if (tuerSerpent(serpent, longueur)) {
+        int choixGameOver;
+        afficherMenuGameOver();
+        afficher_seconde(sec);
+        afficher_minute(min);
+        afficherScore(score);
+        /* Attend le choix du joueur après le game over */
+        choixGameOver = attendreChoixGameOver();
+    }
+
+    /*Vérifier la collision avec les obstacles*/
+    for (i = 0; i < nombreObstacles; i++) {
+        if (estCollisionObstacle(obstacles[i], serpent, longueur)) {
+            int choixGameOver;
+            afficherMenuGameOver();
+            afficher_seconde(sec);
+            afficher_minute(min);
+            afficherScore(score);
+
+            /* Attend le choix du joueur après le game over */
+            choixGameOver = attendreChoixGameOver();
+            if (choixGameOver == 1) {
+                /*Réinitialiser le jeu*/
+                longueur = 10;
+                score = 0;
+                vitesse = 28000000;
+                initialiserSerpent(serpent, &longueur);
+                dessinerGrille();
+                pomme = creerPomme();
+                dessinerPomme(pomme);
+                placerObstacle(obstacles, nombreObstacles, LARGEUR_GRILLE, HAUTEUR_GRILLE);
+            } else if (choixGameOver == 2) {
+                FermerGraphique();
+            }
+        }
+    }
+
+    /*Dessiner le serpent et les obstacles*/
+    dessinerSerpent(serpent, &longueur);
+    for (j = 0; j < nombreObstacles; j++) {
+        dessinerObstacle(obstacles[j]);
+    }
+
+    afficherScore(score);
+    update_timer(&min, &sec);
+
+
+    /*Attendre en fonction de la vitesse actuelle*/
+    attendreSerpent(vitesse);
+    
+}
+free(obstacles);
+}

make_test/jeu.h

@@ -0,0 +1,13 @@
+#ifndef JEU_H
+#define JEU_H
+
+
+
+void afficherScore(int score);
+void lancer_jeu1(void);
+void lancer_jeu2(void);
+void lancer_jeu3(void);
+void lancer_jeu4(void);
+
+
+#endif /*JEU_H*/

make_test/main.c

@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <graph.h>
+#include "main.h"
+#include "jeu.h"
+#include "menu.h"
+
+
+
+
+int menus(void) {
+    int choixMenuPrincipal = 0;
+    int choixModesDeJeu = 0;
+    while (1) {
+        if (choixMenuPrincipal == 0) {
+            afficherMenuPrincipal();
+            choixMenuPrincipal = attendreChoixMenu();
+        } else if (choixMenuPrincipal == 1) {
+            afficherMenuModesDeJeu();
+            choixModesDeJeu = attendreChoixModesDeJeu();
+            if(choixModesDeJeu == 1){
+                EffacerEcran(CouleurParNom("white"));
+                lancer_jeu1();
+            }
+            if(choixModesDeJeu == 2){
+                EffacerEcran(CouleurParNom("white"));
+                lancer_jeu2();
+            }
+            if(choixModesDeJeu == 3){
+                EffacerEcran(CouleurParNom("white"));
+                lancer_jeu3();
+            }
+            if(choixModesDeJeu == 4){
+                EffacerEcran(CouleurParNom("white"));
+                lancer_jeu4();
+            }
+        } else if (choixMenuPrincipal == 2) {
+            FermerGraphique();
+            return EXIT_SUCCESS;
+        }
+    }
+}
+
+
+int main(void){
+    int choixMenuPrincipal = 0;
+    int choixModesDeJeu = 0;
+    InitialiserGraphique();
+    CreerFenetre(0, 0, 1200, 1000);
+    ChoisirTitreFenetre("Snake By Moncef & Marco");
+
+    menus();
+    return EXIT_SUCCESS;
+
+}

make_test/main.h

@@ -0,0 +1,7 @@
+#ifndef MAIN_H
+#define MAIN_H
+
+int main(void);
+int menus(void);
+
+#endif /*MAIN_H*/

make_test/menu.c

@@ -0,0 +1,136 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <graph.h>
+#include "menu.h"
+#include "main.h"
+
+
+
+void afficherMenuPrincipal() {
+    ChargerImageFond("../img/menu_principal.png");
+
+    /* Affiche le bouton "Jouer" */
+    afficherBouton(67, 850, 367, 950, "Jouer", CouleurParComposante(0,151,178), CouleurParNom("black"), CouleurParNom("black"), 2);
+
+    /* Affiche le bouton "Quitter" */
+    afficherBouton(800, 850, 1100, 950, "Quitter", CouleurParComposante(0,151,178), CouleurParNom("black"), CouleurParNom("black"), 2);
+}
+
+void afficherMenuModesDeJeu() {
+    /* Affiche l'image de fond des modes de jeu */
+    ChargerImageFond("../img/modes_de_jeu.png");
+
+    /* Affiche les boutons des modes de jeu */
+    afficherBouton(38.7, 639.9, 280.3, 742.9, "Classique", CouleurParComposante(168, 116, 67), CouleurParNom("black"), CouleurParNom("black"), 2);
+    afficherBouton(332.6, 639.9, 574.2, 742.9, "MultiPommes", CouleurParComposante(168, 116, 67), CouleurParNom("black"), CouleurParNom("black"), 2);
+    afficherBouton(626.2, 639.9, 867.8, 742.9, "Obstacles", CouleurParComposante(168, 116, 67), CouleurParNom("black"), CouleurParNom("black"), 2);
+    afficherBouton(919.7, 639.9, 1161.3, 742.9, "Acceleration", CouleurParComposante(168, 116, 67), CouleurParNom("black"), CouleurParNom("black"), 2);
+}
+
+
+
+
+
+void afficherMenuGameOver(void) {
+    /* Affiche l'image game over */
+    ChargerImageFond("../img/game_over.png");
+}
+
+
+int attendreChoixGameOver() {
+    int x, y;
+
+    while (1) {
+        if (SourisCliquee()) {
+            SourisPosition();
+            x = _X;
+            y = _Y;
+
+            /* Vérifie si le bouton "Menu Principal" est cliqué */
+            if (x >= 379 && x <= 830.7 && y >= 530.3 && y <= 670.1) {
+                EffacerEcran(CouleurParNom("white"));
+                menus(); /* Renvoie vers le menu principal" */
+            }
+
+        }
+    }
+}
+
+
+int attendreChoixModesDeJeu(){
+    int x, y;
+
+    while (1){
+        if(SourisCliquee()){
+            SourisPosition();
+            x = _X;
+            y = _Y;
+
+            /*Vérifie si le bouton n°1 est cliqué*/
+            if (x >= 38.7 && x <= 280.3 && y >= 639.9 && y <= 742.9) {
+                return 1;  /*Renvoie le choix bouton n°1*/
+            }
+
+            /*Vérifie si le bouton n°2 est cliqué*/
+            if (x >= 332.6 && x <= 574.2 && y >= 639.9 && y <= 742.9) {
+                return 2;  /*Renvoie le choix bouton n°2*/
+            }
+
+            /*Vérifie si le bouton n°3 est cliqué*/
+            if (x >= 626.2 && x <= 867.8 && y >= 639.9 && y <= 742.9) {
+                return 3;  /*Renvoie le choix bouton n°3*/
+            }
+
+            /*Vérifie si le bouton n°4 est cliqué*/
+            if (x >= 919.7 && x <= 1161.3 && y >= 639.9 && y <= 742.9) {
+                return 4;  /*Renvoie le choix bouton n°4*/
+            }
+
+        }
+    }
+}
+
+
+int attendreChoixMenu(){
+    int x, y;
+
+    while (1){
+        if (SourisCliquee()){
+            SourisPosition();
+            x = _X;
+            y = _Y;
+
+            /*Vérifie si le bouton "Jouer" est cliqué*/
+            if (x >= 67 && x <= 367 && y >= 850 && y <= 950) {
+                return 1; /*Renvoie le choix bouton "Jouer"*/
+            }
+
+            /*Vérifie si le bouton "Quitter" est cliqué*/
+            if (x >= 800 && x <= 1100 && y >= 850 && y <= 950) {
+                return 2; /*Renvoie le choix bouton "Quitter"*/
+            }
+        }
+    }
+}
+
+void afficherBouton(double x1, double y1, double x2, double y2, const char *texte, couleur arriere_plan, couleur bordure, couleur couleur_texte, int taille_texte) {
+    /* Copie la chaîne constante dans une nouvelle chaîne non constante */
+    char *texte_modifiable = malloc(strlen((const char *)texte) + 1);
+    strcpy(texte_modifiable, (const char *)texte);
+
+    /* Affiche le bouton avec la couleur d'arrière-plan spécifiée */
+    ChoisirCouleurDessin(arriere_plan);
+    RemplirRectangle(x1, y1, x2 - x1, y2 - y1);
+
+    /* Affiche la bordure avec la couleur spécifiée */
+    ChoisirCouleurDessin(bordure);
+    DessinerRectangle(x1, y1, x2 - x1, y2 - y1);
+
+    /* Affiche le texte centré sur le bouton avec la couleur de texte spécifiée */
+    ChoisirCouleurDessin(couleur_texte);
+    EcrireTexte((int)((x1 + x2) / 2 - TailleChaineEcran(texte_modifiable, taille_texte) / 2), (int)((y1 + y2) / 2 + TailleSupPolice(taille_texte) / 2), texte_modifiable, taille_texte);
+
+    /* Libère la mémoire allouée pour la copie de la chaîne */
+    free(texte_modifiable);
+}

make_test/menu.h

@@ -0,0 +1,12 @@
+#ifndef MENU_H
+#define MENU_H
+
+void afficherBouton(double x1, double y1, double x2, double y2, const char *texte, couleur arriere_plan, couleur bordure, couleur couleur_texte, int taille_texte);
+void afficherMenuPrincipal(void);
+void afficherMenuModesDeJeu(void);
+void afficherMenuGameOver(void);
+int attendreChoixGameOver(void);
+int attendreChoixModesDeJeu(void);
+int attendreChoixMenu(void);
+
+#endif  /*MENU_H*/

make_test/obstacle.c

@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <graph.h>
+#include <time.h>
+#include "grille.h"
+#include "serpent.h"
+#include "obstacle.h"
+#include "pomme.h"
+
+
+
+void dessinerObstacle(Obstacle obstacle) {
+    int id_bombe;
+    id_bombe = ChargerSprite("../img/bombe.png");
+    AfficherSprite(id_bombe,obstacle.x * TAILLE_CASE, obstacle.y * TAILLE_CASE);
+}
+
+
+int estCollisionObstacle(Obstacle obstacle, Segment serpent[], int longueur) {
+    int i;
+    for (i = 0; i < longueur; i++) {
+        if (serpent[i].x == obstacle.x && serpent[i].y == obstacle.y) {
+            return 1;  /*Collision avec un obstacle*/
+        }
+    }
+    return 0;  /*Pas de collision*/
+}
+
+Obstacle creerObstacle(int largeurGrille, int hauteurGrille) {
+    Obstacle obstacle;
+    obstacle.x = rand() % largeurGrille;
+    obstacle.y = rand() % hauteurGrille;
+    return obstacle;
+}
+
+void placerObstacle(Obstacle obstacles[], int nombreObstacles, int largeurGrille, int hauteurGrille) {
+    int i;
+    for (i = 0; i < nombreObstacles; i++) {
+        obstacles[i] = creerObstacle(largeurGrille, hauteurGrille);
+    }
+}
+

make_test/obstacle.h

@@ -0,0 +1,17 @@
+#ifndef OBSTACLE_H
+#define OBSTACLE_H
+
+#include "../include/grille.h"
+#include "../include/serpent.h"
+
+typedef struct {
+    int x;
+    int y;
+} Obstacle;
+
+void dessinerObstacle(Obstacle obstacle);
+int estCollisionObstacle(Obstacle obstacle, Segment serpent[], int longueur);
+Obstacle creerObstacle(int largeurGrille, int hauteurGrille);
+void placerObstacle(Obstacle obstacles[], int nombreObstacles, int largeurGrille, int hauteurGrille);
+
+#endif /*OBSTACLE_H*/

make_test/pomme.c

@@ -0,0 +1,34 @@
+#include <stdlib.h>
+#include <graph.h>
+#include "grille.h"
+#include "serpent.h"
+
+typedef struct {
+    int x;
+    int y;
+} Pomme;
+
+Pomme creerPomme() {
+    Pomme pomme;
+    pomme.x = rand() % 60;
+    pomme.y = rand() % 40;
+    return pomme;
+}
+
+void dessinerPomme(Pomme pomme) {
+    /* Affichez une pomme*/
+    int id_pomme;
+    id_pomme = ChargerSprite("../img/pomme1.png");
+    AfficherSprite(id_pomme,pomme.x * TAILLE_CASE, pomme.y * TAILLE_CASE);
+}
+
+int verifierCollisionPommeSerpent(Pomme pomme, Segment serpent[], int longueur) {
+    int i;
+    /*Vérifie si la pomme est sur une case occupée par le serpent*/
+    for (i = 0; i < longueur; ++i) {
+        if (pomme.x == serpent[i].x && pomme.y == serpent[i].y) {
+            return 1; /* Collision */
+        }
+    }
+    return 0; /* Pas de collision */
+}

make_test/pomme.h

@@ -0,0 +1,16 @@
+#ifndef POMME_H
+#define POMME_H
+
+#include "../include/grille.h"
+#include "../include/serpent.h"
+
+typedef struct {
+    int x;
+    int y;
+} Pomme;
+
+Pomme creerPomme();
+void dessinerPomme(Pomme pomme);
+int verifierCollisionPommeSerpent(Pomme pomme, Segment serpent[], int longueur);
+
+#endif /*POMME_H*/

make_test/serpent.c

@@ -0,0 +1,107 @@
+#include <stdio.h>
+#include <graph.h>
+#include "serpent.h"
+#include "main.h"
+#include "timer.h"
+#define TAILLE_CASE 20
+#define LARGEUR_GRILLE 60
+#define HAUTEUR_GRILLE 40
+
+
+void initialiserSerpent(Segment serpent[], int *longueur) {
+    int i;
+    int centreX = LARGEUR_GRILLE / 2;
+    int centreY = HAUTEUR_GRILLE / 2;
+
+    for (i = 0; i < 10; ++i) {
+        serpent[i].x = centreX - i;
+        serpent[i].y = centreY;
+    }
+
+    *longueur = 10;
+}
+
+void gestionDeplacements(Segment serpent[], int *direction_x, int *direction_y) {
+    int touche;
+    if (ToucheEnAttente()) {
+        touche = Touche();
+        if (touche == XK_Up && *direction_y == 0) {
+            *direction_x = 0;
+            *direction_y = -1;
+        } else if (touche == XK_Down && *direction_y == 0) {
+            *direction_x = 0;
+            *direction_y = 1;
+        } else if (touche == XK_Left && *direction_x == 0) {
+            *direction_x = -1;
+            *direction_y = 0;
+        } else if (touche == XK_Right && *direction_x == 0) {
+            *direction_x = 1;
+            *direction_y = 0;
+        } else if (touche == XK_Escape) {
+            FermerGraphique();
+            main();
+        } else if (touche == XK_space) {
+            pause();
+        }
+    }
+}
+
+int tuerSerpent(Segment serpent[], int longueur) {
+    int i;
+    /*Vérifier si la tête du serpent est sortie de la grille après le déplacement*/
+    if (serpent[0].x < 0 || serpent[0].x >= LARGEUR_GRILLE || serpent[0].y < 0 || serpent[0].y >= HAUTEUR_GRILLE) {
+        return 1; /*il est mort*/
+    }
+
+    /*Vérifier si la tête du serpent entre en collision avec son propre corps*/
+    for (i = 1; i < longueur; ++i) {
+        if (serpent[0].x == serpent[i].x && serpent[0].y == serpent[i].y) {
+            return 1; /*il est mort*/
+        }
+    }
+
+    return 0; /*le serpent est en vie*/
+}
+
+
+
+void mettreAJourSerpent(Segment serpent[], int *longueur, int *direction_x, int *direction_y) {
+    int i;
+    int ancienX = serpent[*longueur - 1].x;
+    int ancienY = serpent[*longueur - 1].y;
+
+    /* Déterminer la couleur de fond en fonction de la position de la case dans la grille */
+    couleur couleurFond = (ancienX + ancienY) % 2 == 0 ? CouleurParComposante(170, 215, 82) : CouleurParComposante(180, 220, 90);
+
+    /* Remplir la case avec la couleur de fond appropriée */
+    ChoisirCouleurDessin(couleurFond);
+    RemplirRectangle(ancienX * TAILLE_CASE, ancienY * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
+
+    /* Remplir la case avec la couleur de la grille à cet endroit précis */
+    ChoisirCouleurDessin(CouleurParComposante(170, 215, 82)); 
+    RemplirRectangle(0, 0, TAILLE_CASE, TAILLE_CASE);
+
+    for (i = *longueur - 1; i > 0; --i) {
+        serpent[i] = serpent[i - 1];
+    }
+    serpent[0].x += *direction_x;
+    serpent[0].y += *direction_y;
+
+    tuerSerpent(serpent, *longueur); /*Appeler la fonction pour vérifier si le serpent est mort*/
+}
+
+
+void dessinerSerpent(Segment serpent[], int *longueur) {
+    int i;
+    for (i = 0; i < *longueur; ++i) {
+        ChoisirCouleurDessin(CouleurParNom("yellow"));
+        RemplirRectangle(serpent[i].x * TAILLE_CASE, serpent[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
+    }
+}
+
+void attendreSerpent(unsigned long int microseconds) {
+    unsigned long int attente_jusqu_a = Microsecondes() + microseconds;
+    while (Microsecondes() < attente_jusqu_a) {
+        /*Attendre jusqu'au temps données en paramètre de la fonction*/
+    }
+}

make_test/serpent.h

@@ -0,0 +1,16 @@
+#ifndef SERPENT_H
+#define SERPENT_H
+
+typedef struct {
+    int x, y;
+} Segment;
+
+void initialiserSerpent(Segment serpent[], int *longueur);
+void gestionDeplacements(Segment serpent[], int *direction_x, int *direction_y);
+int tuerSerpent(Segment serpent[], int longueur);
+void mettreAJourSerpent(Segment serpent[], int *longueur, int *direction_x, int *direction_y);
+void dessinerSerpent(Segment serpent[], int *longueur);
+int seMangerQueue(Segment serpent[], int longueur);
+void attendreSerpent(unsigned long int microseconds);
+
+#endif /*SERPENT_H*/

make_test/timer.c

@@ -0,0 +1,82 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <graph.h>
+#include "timer.h"
+
+#define cycle 1000000L
+
+void initialiser_timer(int *min, int *sec) {
+    *min = 0;
+    *sec = 0;
+}
+
+int afficher_seconde(int sec){
+    char timer[50];
+    int x = 230 ,y = 850;
+    if(sec<=9){
+        ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
+        RemplirRectangle(x-3,y-25,40,30);
+        ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
+        EcrireTexte(x,y,"0",2);
+        snprintf(timer,sizeof(timer),"%d",sec);
+        EcrireTexte(x+15,y,timer,2);
+    } else {
+        ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
+        RemplirRectangle(x-3,y-25,40,25);
+        ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
+        snprintf(timer,sizeof(timer),"%d",sec);
+        EcrireTexte(x,y,timer,2);
+    }
+    return sec;
+}
+
+int afficher_minute(int min){
+    char timer[50];
+    int x = 190 ,y = 850;
+    if(min<=9){
+        ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
+        RemplirRectangle(x-3,y-25,40,30);
+        ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
+        EcrireTexte(x,y,"0",2);
+        snprintf(timer,sizeof(timer),"%d",min);
+        EcrireTexte(x+30,y,":",2);
+        EcrireTexte(x+15,y,timer,2);
+    } else {
+        ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
+        RemplirRectangle(x-3,y-25,40,25);
+        ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
+        snprintf(timer,sizeof(timer),"%d",min);
+        EcrireTexte(x+30,y,":",2);
+        EcrireTexte(x,y,timer,2);
+    }
+    return min;
+}
+
+void update_timer(int *min, int *sec) {
+    static unsigned long int temps_precedent = 0;
+    unsigned long int temps_actuel = Microsecondes();
+    unsigned long int temps_ecoule = temps_actuel - temps_precedent;
+
+    if (temps_ecoule >= cycle) {
+        temps_precedent = temps_actuel;
+        
+        if (*sec < 59) {
+            (*sec)++;
+        } else {
+            *sec = 0;
+            (*min)++;
+        }
+
+        /* Afficher le timer */
+        afficher_seconde(*sec);
+        afficher_minute(*min);
+    }
+}
+
+void pause(void) {
+    while (1) {
+        if (ToucheEnAttente() && Touche() == XK_space) {
+            break;
+        }
+    }
+}

make_test/timer.h

@@ -0,0 +1,10 @@
+#ifndef TIMER_H
+#define TIMER_H
+
+void initialiser_timer(int *min, int *sec);
+int afficher_seconde(int sec);
+int afficher_minute(int min);
+void update_timer(int *min, int *sec);
+void pause(void);
+
+#endif /* TIMER_H */