T

essai.c

@@ -0,0 +1,168 @@
+#include <stdlib.h>
+#include <graph.h>
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#define HAUTEUR 40
+#define LARGEUR 60
+#define TAILLE_CASE 20
+#define NOMBRE_POMMES 5
+
+typedef struct {
+    int x;
+    int y;
+} Segment;
+
+/* Fonction pour attendre un certain nombre de millisecondes */
+void Attendre(unsigned int millisecondes) {
+    usleep(millisecondes * 1000);
+}
+
+/* Fonction pour concevoir le graphique */
+void Graphique() {
+    InitialiserGraphique();
+    CreerFenetre(10, 10, 1240, 940);
+    EcrireTexte(500, 400, "Le jeu va commencer !", 2);
+    sleep(1);
+    EffacerEcran(CouleurParComposante(0, 0, 0));
+}
+
+/* Fonction pour afficher le serpent */
+void afficherSerpent(Segment serpent[], int taille) {
+    couleur couleurSerpent = CouleurParComposante(255, 255, 0);
+    ChoisirCouleurDessin(couleurSerpent);
+
+    for (int i = 0; i < taille; i++) {
+        RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
+    }
+}
+
+/* Fonction pour générer les pommes */
+void genererPommes(Segment pommes[]) {
+    for (int i = 0; i < NOMBRE_POMMES; i++) {
+        pommes[i].x = (rand() % LARGEUR) * TAILLE_CASE;
+        pommes[i].y = (rand() % HAUTEUR) * TAILLE_CASE;
+        ChoisirCouleurDessin(CouleurParComposante(255, 0, 0));
+        RemplirRectangle(pommes[i].x, pommes[i].y, TAILLE_CASE, TAILLE_CASE);
+    }
+}
+
+/* Fonction pour déplacer le serpent */
+void deplacerSerpent(int longueurSerpent, Segment serpent[], int *direction) {
+    couleur c;
+    couleur v;
+    couleur s;
+    c = CouleurParComposante(0, 0, 0);
+    s = CouleurParComposante(255, 255, 0);
+    v = CouleurParComposante(111, 255, 94);
+
+    for (int i = 0; i < longueurSerpent; i++) {
+        ChoisirCouleurDessin(v);
+        RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
+    }
+
+    for (int i = longueurSerpent - 1; i > 0; i--) {
+        serpent[i] = serpent[i - 1];
+    }
+
+    if (ToucheEnAttente()) {
+        int touche = Touche();
+        switch (touche) {
+            case XK_Right:
+                *direction = 1;
+                break;
+            case XK_Left:
+                *direction = 2;
+                break;
+            case XK_Up:
+                *direction = 3;
+                break;
+            case XK_Down:
+                *direction = 4;
+                break;
+        }
+    }
+
+    /* Déplace la tête en fonction de la direction */
+    if (*direction == 1) {
+        serpent[0].x += TAILLE_CASE;
+    } else if (*direction == 2) {
+        serpent[0].x -= TAILLE_CASE;
+    } else if (*direction == 3) {
+        serpent[0].y -= TAILLE_CASE;
+    } else if (*direction == 4) {
+        serpent[0].y += TAILLE_CASE;
+    }
+
+    for (int i = 0; i < longueurSerpent; i++) {
+        ChoisirCouleurDessin(s);
+        RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
+    }
+
+    Attendre(100);
+}
+
+/* Fonction pour gérer les collisions */
+int gererCollisions(Segment snake[], int *taille, Segment pommes[]) {
+    /* Vérifie la collision avec la pomme */
+    for (int i = 0; i < NOMBRE_POMMES; i++) {
+        if (snake[0].x == pommes[i].x && snake[0].y == pommes[i].y) {
+            /* Augmente la taille du serpent et génère une nouvelle pomme */
+            (*taille)++;
+            genererPommes(pommes);
+            return 1; /* Le serpent a mangé une pomme */
+        }
+    }
+
+    /* Vérifie la collision avec les parois */
+    if (snake[0].x < 0 || snake[0].x >= LARGEUR * TAILLE_CASE || snake[0].y < 0 || snake[0].y >= HAUTEUR * TAILLE_CASE) {
+        return -1; /* Collision avec la paroi */
+    }
+
+    /* Vérifie la collision avec le corps du serpent */
+    for (int i = 1; i < *taille; i++) {
+        if (snake[0].x == snake[i].x && snake[0].y == snake[i].y) {
+            return -1; /* Collision avec le corps du serpent */
+        }
+    }
+
+    return 0; /* Pas de collision */
+}
+
+int main() {
+    int perdu = 0, direction = 1, longueurSerpent = 10;
+    Segment serpent[LARGEUR * HAUTEUR];
+    Segment pommes[NOMBRE_POMMES];
+    couleur c = CouleurParComposante(0, 0, 0);
+    couleur v = CouleurParComposante(111, 255, 94);
+    couleur s = CouleurParComposante(255, 255, 0);
+    srand(time(NULL));
+
+    /* Position initiale du serpent au milieu du tableau */
+    serpent[0].x = LARGEUR / 2 * TAILLE_CASE;
+    serpent[0].y = HAUTEUR / 2 * TAILLE_CASE;
+
+    Graphique();
+    InitialiserGraphique();
+    CreerFenetre(10, 10, 1200, 820);
+    EffacerEcran(c);
+    AffichageBasique();
+    genererPommes(pommes);
+    afficherSerpent(serpent, longueurSerpent);
+
+    while (perdu != -1) {
+        deplacerSerpent(longueurSerpent, serpent, &direction);
+        perdu = gererCollisions(serpent, &longueurSerpent, pommes);
+
+        if (perdu == -1) {
+            printf("Vous avez perdu ! Collision avec la paroi ou le corps du serpent.\n");
+            FermerGraphique();
+        }
+    }
+
+    /* Attend que l'utilisateur appuie sur une touche avant de fermer la fenêtre graphique */
+    Touche();
+    FermerGraphique();
+    return EXIT_SUCCESS;
+}

essai.c~

@@ -0,0 +1,169 @@
+#include <stdlib.h>
+#include <graph.h>
+#include <time.h>
+#include <unistd.h> // Ajout de l'en-tête pour usleep
+#include <stdio.h>
+
+#define HAUTEUR 40
+#define LARGEUR 60
+#define TAILLE_CASE 20
+#define ESPACE_HAUT 35
+#define ESPACE_BAS 85
+#define NOMBRE_POMMES 5
+#define CYCLE 100000L
+
+typedef struct {
+    int x;
+    int y;
+} Segment;
+
+/* Fonction pour attendre un certain nombre de millisecondes */
+void Attendre(unsigned int millisecondes) {
+    usleep(millisecondes * 1000);
+}
+
+/* Fonction pour concevoir le graphique */
+void Graphique() {
+    InitialiserGraphique();
+    CreerFenetre(10, 10, 1240, 940);
+    EcrireTexte(500, 400, "Le jeu va commencer !", 2);
+    sleep(1);
+    EffacerEcran(CouleurParComposante(0, 0, 0));
+}
+
+/* Fonction pour afficher le serpent */
+void afficherSerpent(Segment serpent[], int taille) {
+    int i;
+    couleur couleurSerpent = CouleurParNom("yellow");
+    ChoisirCouleurDessin(couleurSerpent);
+
+    for (i = 0; i < taille; i++) {
+        RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
+    }
+}
+
+/* Fonction pour générer les pommes */
+void genererPommes(Segment pommes[]) {
+    for (int i = 0; i < NOMBRE_POMMES; i++) {
+        pommes[i].x = rand() % LARGEUR * TAILLE_CASE;
+        pommes[i].y = rand() % HAUTEUR * TAILLE_CASE;
+        ChoisirCouleurDessin(CouleurParComposante(255, 0, 0));
+        RemplirRectangle(pommes[i].x, pommes[i].y, TAILLE_CASE, TAILLE_CASE);
+    }
+}
+
+/* Fonction pour déplacer le serpent */
+void deplacerSerpent(int longueurSerpent, Segment serpent[], int *direction) {
+    int i;
+    couleur c;
+    couleur v;
+    couleur s;
+    c = CouleurParComposante(0, 0, 0);
+    s = CouleurParComposante(255, 255, 0);
+    v = CouleurParComposante(111, 255, 94);
+
+    for (i = 0; i < longueurSerpent; i++) {
+        ChoisirCouleurDessin(v);
+        RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
+    }
+    for (i = longueurSerpent - 1; i > 0; i--) {
+        serpent[i] = serpent[i - 1];
+    }
+
+    if (ToucheEnAttente()) {
+        int touche = Touche();
+        switch (touche) {
+            case XK_Right:
+                *direction = 1;
+                break;
+            case XK_Left:
+                *direction = 2;
+                break;
+            case XK_Up:
+                *direction = 3;
+                break;
+            case XK_Down:
+                *direction = 4;
+                break;
+        }
+    }
+    /* Déplace la tête en fonction de la direction */
+    if (*direction == 1) {
+        serpent[0].x += TAILLE_CASE;
+    } else if (*direction == 2) {
+        serpent[0].x -= TAILLE_CASE;
+    } else if (*direction == 3) {
+        serpent[0].y -= TAILLE_CASE;
+    } else if (*direction == 4) {
+        serpent[0].y += TAILLE_CASE;
+    }
+
+    for (i = 0; i < longueurSerpent; i++) {
+        ChoisirCouleurDessin(s);
+        RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
+    }
+    Attendre(100);
+}
+
+/* Fonction pour gérer les collisions */
+int gererCollisions(Segment snake[], int *taille, Segment pommes[], int *aMangerPomme) {
+    /* Vérifie la collision avec la pomme */
+    for (int i = 0; i < NOMBRE_POMMES; i++) {
+        if (snake[0].x == pommes[i].x && snake[0].y == pommes[i].y) {
+            /* Augmente la taille du serpent et génère une nouvelle pomme */
+            (*taille)++;
+            *aMangerPomme = 1;
+            genererPommes(pommes);
+            return 1; /* Le serpent a mangé une pomme */
+        }
+    }
+    /* Vérifie la collision avec les parois */
+    if (snake[0].x <= 0 || snake[0].x >= LARGEUR * TAILLE_CASE || snake[0].y <= 0 || snake[0].y >= HAUTEUR * TAILLE_CASE) {
+        return -1; /* Collision avec la paroi */
+    }
+    /* Vérifie la collision avec le corps du serpent */
+    for (int i = 1; i < *taille; i++) {
+        if (snake[0].x == snake[i].x && snake[0].y == snake[i].y) {
+            return -1; /* Collision avec le corps du serpent */
+        }
+    }
+    return 0; /* Pas de collision */
+}
+
+/* Fonction pour afficher un fond basique */
+void AffichageBasique() {
+    ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
+    RemplirRectangle(10, 10, TAILLE_CASE * LARGEUR, TAILLE_CASE * LARGEUR);
+}
+
+int main() {
+    int touche, perdu = 0, direction = 1, longueurSerpent = 10;
+    Segment serpent[LARGEUR * HAUTEUR];
+    Segment pommes[NOMBRE_POMMES];
+    couleur c = CouleurParComposante(0, 0, 0);
+    couleur v = CouleurParComposante(111, 255, 94);
+    couleur s = CouleurParComposante(255, 255, 0);
+    srand(time(NULL));
+
+    Graphique();
+    InitialiserGraphique();
+    CreerFenetre(10, 10, 1200, 820);
+    EffacerEcran(c);
+    AffichageBasique();
+    genererPommes(pommes);
+    afficherSerpent(serpent, longueurSerpent);
+
+    while (perdu != -1) {
+        deplacerSerpent(longueurSerpent, serpent, &direction);
+        perdu = gererCollisions(serpent, &longueurSerpent, pommes, &direction);
+
+        if (perdu == -1) {
+            printf("Vous avez perdu ! Collision avec la paroi ou le corps du serpent.\n");
+            FermerGraphique();
+        }
+    }
+
+    Touche();
+    FermerGraphique();
+    return EXIT_SUCCESS;
+}

final.c

@@ -1,68 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <graph.h>
-#include <time.h>
-#include <unistd.h>
-
-#define HAUTEUR 40
-#define LARGEUR 60
-#define CYCLE 100000L
-#define SEGMENT 10
-
-/* Enumeration des différentes directions possibles */
-enum dir { UP = 2, DOWN = 3, LEFT = 0, RIGHT = 1 };
-
-/* Structure pour stocker les coordonnées des segments du serpent */
-typedef struct {
-    int x,y;
-}SnakePoint;
-
-typedef struct {
-    int posx, posy;
-} PommePoint;
-
-/* Fonction pour afficher le serpent */
-void serpent(SnakePoint *snake, int taille) {
-    for (int i = 0; i < taille; i++) {
-        couleur s = CouleurParComposante(255, 255, 0);
-        ChoisirCouleurDessin(s);
-        RemplirRectangle(snake[i].x * SEGMENT, snake[i].y * SEGMENT, SEGMENT, SEGMENT);
-    }
-}
-
-void pomme(SnakePoint *pommes){
-   /* Vérifie si le serpent a mangé la pomme à partir des coordonnées et génère une nouvelle pomme */
-   for (int i = 0; i < 5; i++) {
-        pommes[i].x = rand() % LARGEUR;
-        pommes[i].y = rand() % HAUTEUR;
-     couleur p = CouleurParComposante(255,0, 0);
-        ChoisirCouleurDessin(s);
-        RemplirRectangle(pomme[i].x, pomme[i].y);
-   }
-
-   void MouvenmentTete(SnakePoint *){
-       for (int i = *taille - 1; i > 0; i--) {
-        snake[i] = snake[i - 1];
-    }
-
-    /* Déplace la tête en fonction de la direction */
-    if (*dir == LEFT) {
-        snake[0].posx = (snake[0].posx - 1 + LARGEUR) % LARGEUR;
-    } else if (*dir == RIGHT) {
-        snake[0].posx = (snake[0].posx + 1) % LARGEUR;
-    } else if (*dir == UP) {
-        snake[0].posy = (snake[0].posy - 1 + HAUTEUR) % HAUTEUR;
-    } else if (*dir == DOWN) {
-        snake[0].posy = (snake[0].posy + 1) % HAUTEUR;
-    }
-
-  
-    
-
-    
-
-
-
-
-
-

graphique.c

@@ -1,60 +0,0 @@
-#include<stdlib.h>
-#include<stdio.h>
-#include<graph.h>
-#include<time.h>
-
-#define H 40
-#define L 60
-#define CYCLE 100000L;
-
-void graphique(int n){
- InitialiserGraphique();
-    CreerFenetre(1700,950,1700,950);
-    couleur c, b;
-    b=CouleurParComposante(0,0,0);
-    ChoisirCouleurDessin(b);
-    RemplirRectangle(0,0,1750,950);
-    c=CouleurParComposante(111,255,94);
-    ChoisirCouleurDessin(c);
-    RemplirRectangle(100,100,1500,750);
-    Touche(); 
-    FermerGraphique();
-    };
-    enum Direction {Stop=0,Droite=XK_Right,Gauche=XK_Left,Haut=XK_Up,Bas=XK_Down};
-    enum Direction direction;
-
-void snake(){
-  couleur s;
-   s=CouleurParNom("yellow");
-    ChoisirCouleurDessin(s);
-    RemplirRectangle(200,200);
-  
-}
-int main(void){
-  int n;
-graphique();
-  int tab[H][L];
-  int i,j,posx=100,posy=100,n=0;
-  double suivant;
-  suivant=Microseconde()+CYCLE;
-  for(i=0;i<H;i++){
-    for(j=0;j<L;j++){
-      tab[i][j]=0;
-    }
-  }
-  while(1){
-    if (Microsecondes()>suivant){
-      n++;
-      graphique();
-      suivant= Microseconde()+CYCLE;
-    }
-  }
-  
-      
-  
- 
-  return EXIT_SUCCESS;
-}
- 
-
- 

idée.c

@@ -1,132 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <graph.h>
-#include <time.h>
-
-#define LARGEUR_FENETRE 1080
-#define HAUTEUR_FENETRE 1080
-#define TAILLE_CASE 5
-#define NOMBRE_CASES_X (LARGEUR_FENETRE / TAILLE_CASE)
-#define NOMBRE_CASES_Y (HAUTEUR_FENETRE / TAILLE_CASE)
-
-enum direction{UP,DOWN,RIGHT,LEFT};
-
-typedef struct {
-    int x, y;
-} Position;
-
-typedef struct {
-    Position position;
-    int taille;
-    Position queue[10]; // Augmentez la taille si nécessaire
-} Snake;
-
-typedef struct {
-    Position position;
-} Fruit;
-
-void initialiserGraphique() {
-    InitialiserGraphique();
-    CreerFenetre(LARGEUR_FENETRE, HAUTEUR_FENETRE, LARGEUR_FENETRE, HAUTEUR_FENETRE);
-}
-
-void dessinerCase(Position position, couleur c) {
-    ChoisirCouleurDessin(c);
-    RemplirRectangle(position.x * TAILLE_CASE, position.y * TAILLE_CASE, (position.x + 1) * TAILLE_CASE, (position.y + 1) * TAILLE_CASE);
-}
-
-void afficherSnake(Snake *snake) {
-    couleur couleurSnake = CouleurParComposante(0, 255, 0); // Vert
-    for (int i = 0; i < snake->taille; i++) {
-        dessinerCase(snake->queue[i], couleurSnake);
-    }
-}
-
-void afficherFruit(Fruit *fruit) {
-    couleur couleurFruit = CouleurParComposante(255, 0, 0); // Rouge
-    dessinerCase(fruit->position, couleurFruit);
-}
-
-void deplacerSnake(Snake *snake) {
-    // Déplacer la queue
-    for (int i = snake->taille - 1; i > 0; i--) {
-        snake->queue[i] = snake->queue[i - 1];
-    }
-
-    // Déplacer la tête
-    if (ToucheEnAttente()) {
-      int touche = Touche();
-        if (touche == UP) {
-            snake->queue[0].y--;
-        } else if (touche == DOWN) {
-            snake->queue[0].y++;
-        } else if (touche == LEFT) {
-            snake->queue[0].x--;
-        } else if (touche == RIGHT) {
-            snake->queue[0].x++;
-        }
-    }
-
-int collisionAvecFruit(Snake *snake, Fruit *fruit) {
-    return snake->queue[0].x == fruit->position.x && snake->queue[0].y == fruit->position.y;
-}
-
-int collisionAvecMur(Snake *snake) {
-    return snake->queue[0].x < 0 || snake->queue[0].x >= NOMBRE_CASES_X ||
-           snake->queue[0].y < 0 || snake->queue[0].y >= NOMBRE_CASES_Y;
-}
-
-int collisionAvecQueue(Snake *snake) {
-    for (int i = 1; i < snake->taille; i++) {
-        if (snake->queue[0].x == snake->queue[i].x && snake->queue[0].y == snake->queue[i].y) {
-            return 1;
-        }
-    }
-}
-    return 0;
-}
-*/
-void jeuSnake() {
-    initialiserGraphique();
-
-    Snake snake;
-    snake.position.x = NOMBRE_CASES_X / 2;
-    snake.position.y = NOMBRE_CASES_Y / 2;
-    snake.taille = 1;
-
-    Fruit fruit;
-    srand(time(NULL));
-    fruit.position.x = rand() % NOMBRE_CASES_X;
-    fruit.position.y = rand() % NOMBRE_CASES_Y;
-
-    while (1) {
-      EffacerEcran(0);
-        
-        deplacerSnake(&snake);
-        afficherSnake(&snake);
-        afficherFruit(&fruit);
-
-        if (collisionAvecFruit(&snake, &fruit)) {
-            // Manger le fruit
-            snake.taille++;
-            fruit.position.x = rand() % NOMBRE_CASES_X;
-            fruit.position.y = rand() % NOMBRE_CASES_Y;
-        }
-
-        if (collisionAvecMur(&snake) || collisionAvecQueue(&snake)) {
-            FermerGraphique();
-            printf("Game Over!\n");
-            break;
-        }
-    }
-}
-
-int main(void) {
-  while(1){
-  initialiserGraphique();
-     dessinerCase();  
-    jeuSnake();
-    afficherSnake();
-  }
-    return EXIT_SUCCESS;
-}

jeu.c

@@ -1,189 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <graph.h>
-#include <time.h>
-
-#define HAUTEUR 40
-#define LARGEUR 60
-#define CYCLE 100000L
-#define TAILLE_CASE 20
-#define SCORE_TO_WIN 5
-
-/* Enumeration des différentes directions possibles */
-enum Direction { UP = 2, DOWN = 3, LEFT = 0, RIGHT = 1 };
-
-/* Structure pour stocker les coordonnées des segments du serpent */
-typedef struct {
-    int posx, posy;
-} SnakePoint;
-
-/* Fonction pour concevoir le graphique */
-void graphique() {
-    InitialiserGraphique();
-    CreerFenetre(10, 10, 1240, 940);
-    EcrireTexte(500, 400, "Le jeu va commencer !", 2);
-    sleep(1);
-    EffacerEcran(CouleurParComposante(0, 0, 0));
-}
-
-void AffichageBasique() {
-    ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
-    RemplirRectangle(10, 10, 1200, 820);
-}
-
-void AfficheTemps(int minute, int seconde) {
-    char temps[6];
-    snprintf(temps, 6, "%02d:%02d", minute, seconde);
-
-    ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
-    RemplirRectangle(20, 870, 70, 40);
-
-    ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
-    EcrireTexte(20, 900, temps, 2);
-}
-
-/* Fonction pour afficher le serpent */
-void serpent(SnakePoint *snake, int taille) {
-    for (int i = 0; i < taille; i++) {
-        couleur s = CouleurParComposante(255, 255, 0);
-        ChoisirCouleurDessin(s);
-        RemplirRectangle(snake[i].posx * TAILLE_CASE, snake[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
-    }
-}
-
-/* Fonction pour générer les pommes */
-void genererPommes(SnakePoint *pommes) {
-    for (int i = 0; i < 5; i++) {
-        pommes[i].posx = rand() % (LARGEUR - 2) + 1;
-        pommes[i].posy = rand() % (HAUTEUR - 2) + 1;
-        couleur p = CouleurParComposante(255, 0, 0);
-        ChoisirCouleurDessin(p);
-        RemplirRectangle(pommes[i].posx * TAILLE_CASE, pommes[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
-    }
-}
-
-/* Fonction pour gérer le mouvement de la tête du serpent */
-void mouvementTete(SnakePoint *snake, int *taille, int *score, int *dir) {
-    /* Déplace la tête en fonction de la direction */
-    if (ToucheEnAttente()) {
-        int touche = Touche();
-        switch (touche) {
-            case XK_Left:
-                *dir = LEFT;
-                break;
-            case XK_Right:
-                *dir = RIGHT;
-                break;
-            case XK_Up:
-                *dir = UP;
-                break;
-            case XK_Down:
-                *dir = DOWN;
-                break;
-        }
-
-        /* Déplace la tête en fonction de la direction */
-        if (*dir == LEFT) {
-            snake[0].posx -= 1;
-        } else if (*dir == RIGHT) {
-            snake[0].posx += 1;
-        } else if (*dir == UP) {
-            snake[0].posy -= 1;
-        } else if (*dir == DOWN) {
-            snake[0].posy += 1;
-        }
-    }
-}
-
-/* Fonction pour gérer le mouvement du corps du serpent */
-void mouvementCorps(SnakePoint *snake, int taille) {
-    /* Déplace le corps du serpent en suivant la tête */
-    for (int i = taille - 1; i > 0; i--) {
-        snake[i] = snake[i - 1];
-    }
-}
-
-/* Fonction pour gérer les collisions */
-int gererCollisions(SnakePoint *snake, int *taille, int *score, SnakePoint *pommes) {
-    /* Vérifie la collision avec la pomme */
-    for (int i = 0; i < 5; i++) {
-        if (snake[0].posx == pommes[i].posx && snake[0].posy == pommes[i].posy) {
-            /* Augmente le score et génère une nouvelle pomme */
-            *score += 5;
-            pommes[i].posx = rand() % (LARGEUR - 2) + 1;
-            pommes[i].posy = rand() % (HAUTEUR - 2) + 1;
-            return 1; /* Le serpent a mangé une pomme */
-        }
-    }
-
-    /* Vérifie la collision avec la paroi intérieure du rectangle */
-    if (snake[0].posx <= 0 || snake[0].posx >= LARGEUR - 1 || snake[0].posy <= 0 || snake[0].posy >= HAUTEUR - 1) {
-        return -1; /* Collision avec la paroi */
-    }
-
-    return 0; /* Pas de collision */
-}
-
-int main() {
-    /* Initialisation du jeu */
-    graphique();
-    SnakePoint snake[LARGEUR * HAUTEUR];
-    SnakePoint pommes[5];
-    int taille = 1;
-    int score = 0;
-    int dir;
-
-    srand(time(NULL));
-
-    /* Position initiale du serpent au milieu du tableau */
-    snake[0].posx = LARGEUR / 2;
-    snake[0].posy = HAUTEUR / 2;
-
-    graphique();
-    AffichageBasique();
-    genererPommes(pommes);
-
-    unsigned long suivant = Microsecondes() + CYCLE;
-    int perdu = 0;
-    int temps[2] = {0, 0}, seconde_actuel, old_seconde;
-
-    while (!perdu) {
-        /* Calcul du temps */
-        if (Microsecondes() > suivant) {
-            suivant = Microsecondes() + CYCLE;
-            seconde_actuel = (suivant / 1000000) % 10;
-            if (seconde_actuel != old_seconde) {
-                old_seconde = seconde_actuel;
-                if ((temps[1] + 1) == 60) {
-                    temps[0]++;
-                    temps[1] = 0;
-                } else {
-                    temps[1]++;
-                }
-                /* Affichage du temps */
-                AfficheTemps(temps[0], temps[1]);
-            }
-
-            /* Déplacement du serpent */
-            mouvementTete(snake, &taille, &score, &dir);
-            mouvementCorps(snake, taille);
-            perdu = gererCollisions(snake, &taille, &score, pommes);
-            serpent(snake, taille);
-
-            /* Génération de nouvelles pommes si le serpent en a mangé une */
-            if (perdu == 1) {
-                genererPommes(pommes);
-            }
-        }
-    }
-
-    if (perdu == -1) {
-        printf("Vous avez perdu ! Collision avec la paroi.\n");
-    } else {
-        printf("Vous avez gagné avec un score de %d points ! Félicitations.\n", score);
-    }
-
-    FermerGraphique();
-
-    return EXIT_SUCCESS;
-}

serpent.c

@@ -1,23 +1,35 @@
 #include <stdlib.h>
-#include <stdio.h>
 #include <graph.h>
 #include <time.h>
+#include <stdio.h>
 
 #define HAUTEUR 40
 #define LARGEUR 60
-#define CYCLE 100000L
 #define TAILLE_CASE 20
+#define NOMBRE_POMMES 5
+#define CYCLE 100000L
 
-/* Enumeration des différentes directions possibles */
-enum Direction { UP = 2, DOWN = 3, LEFT = 0, RIGHT = 1 };
-
-/* Structure pour stocker les coordonnées des segments du serpent */
 typedef struct {
-    int posx, posy;
+    int x;
-} SnakePoint;
+    int y;
+} Segment;
+
+typedef struct {
+    int x;
+    int y;
+} Pomme;
+
+typedef struct {
+    int longueur;
+    Segment* corps;
+} Serpent;
+
+void Attendre(unsigned int millisecondes) {
+    usleep(millisecondes * 1000);
+}
 
 /* Fonction pour concevoir le graphique */
-void graphique() {
+void Graphique() {
     InitialiserGraphique();
     CreerFenetre(10, 10, 1240, 940);
     EcrireTexte(500, 400, "Le jeu va commencer !", 2);
@@ -25,163 +37,153 @@ void graphique() {
     EffacerEcran(CouleurParComposante(0, 0, 0));
 }
 
-void AffichageBasique() {
+/* Fonction permettant d'afficher le serpent */
-    ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
+void afficherSerpent(Serpent serpent) {
-    RemplirRectangle(10, 10, 1200, 820);
+    couleur couleurSerpent = CouleurParNom("yellow");
-}
+    ChoisirCouleurDessin(couleurSerpent);
 
-void AfficheTemps(int minute, int seconde) {
+    for (int i = 0; i < serpent.longueur; i++) {
-    char temps[6];
+        RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
-    snprintf(temps, 6, "%02d:%02d", minute, seconde);
-
-    ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
-    RemplirRectangle(20, 870, 70, 40);
-
-    ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
-    EcrireTexte(20, 900, temps, 2);
-}
-
-/* Fonction pour afficher le serpent */
-void serpent(SnakePoint *snake, int taille) {
-    for (int i = 0; i < taille; i++) {
-        couleur s = CouleurParComposante(255, 255, 0);
-        ChoisirCouleurDessin(s);
-        RemplirRectangle(snake[i].posx * TAILLE_CASE, snake[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
     }
 }
 
-/* Fonction pour générer les pommes */
+void genererPommes(Pomme pommes[]) {
-void genererPommes(SnakePoint *pommes) {
+    for (int i = 0; i < NOMBRE_POMMES; i++) {
-    for (int i = 0; i < 5; i++) {
+        pommes[i].x = rand() % LARGEUR * TAILLE_CASE;
-        pommes[i].posx = rand() % LARGEUR;
+        pommes[i].y = rand() % HAUTEUR * TAILLE_CASE;
-        pommes[i].posy = rand() % HAUTEUR;
+        ChoisirCouleurDessin(CouleurParComposante(255, 0, 0));
-        couleur p = CouleurParComposante(255, 0, 0);
+        RemplirRectangle(pommes[i].x, pommes[i].y, TAILLE_CASE, TAILLE_CASE);
-        ChoisirCouleurDessin(p);
-        RemplirRectangle(pommes[i].posx * TAILLE_CASE, pommes[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
     }
 }
 
-/* Fonction pour gérer le mouvement de la tête du serpent */
+/* Fonction initialisant la fenetre de jeux en vert */
-void mouvementTete(SnakePoint *snake, int *dir) {
+void EcranJeu() {
-    /* Déplace la tête en fonction de la direction */
+    couleur v = CouleurParNom("light green");
+    for (int i = 2; i < 42; i++) {
+        for (int j = 5; j < 65; j++) {
+            ChoisirCouleurDessin(v);
+            RemplirRectangle(j * TAILLE_CASE, i * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
+        }
+    }
+}
+
+int collisionAvecPomme(Serpent serpent, Pomme pomme) {
+    return (serpent.corps[0].x == pomme.x && serpent.corps[0].y == pomme.y);
+}
+
+int collisionAvecBordures(Serpent serpent) {
+    return (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE ||
+            serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE);
+}
+
+int collisionAvecSerpent(Serpent serpent) {
+    for (int i = 1; i < serpent.longueur; i++) {
+        if (serpent.corps[0].x == serpent.corps[i].x && serpent.corps[0].y == serpent.corps[i].y) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+void gestionCollision(Serpent *serpent, Pomme pommes[]) {
+    if (collisionAvecPomme(*serpent, pommes[0])) {
+        serpent->longueur++;
+        serpent->corps = realloc(serpent->corps, sizeof(Segment) * serpent->longueur);
+        genererPommes(pommes);
+    }
+
+    if (collisionAvecSerpent(*serpent) || collisionAvecBordures(*serpent)) {
+        FermerGraphique();
+        exit(EXIT_SUCCESS);
+    }
+}
+
+void deplacerSerpent(Serpent *serpent, int *direction) {
+    int i;
+    couleur c;
+    couleur v;
+    couleur s;
+    c = CouleurParNom("black");
+    s = CouleurParNom("yellow");
+    v = CouleurParNom("light green");
+
+    for (i = 0; i < serpent->longueur; i++) {
+        ChoisirCouleurDessin(v);
+        RemplirRectangle(serpent->corps[i].x, serpent->corps[i].y, TAILLE_CASE, TAILLE_CASE);
+    }
+    for (i = serpent->longueur - 1; i > 0; i--) {
+        serpent->corps[i] = serpent->corps[i - 1];
+    }
+
     if (ToucheEnAttente()) {
         int touche = Touche();
         switch (touche) {
-            case XK_Left:
-                *dir = LEFT;
-                break;
             case XK_Right:
-                *dir = RIGHT;
+                *direction = 1;
+                break;
+            case XK_Left:
+                *direction = 2;
                 break;
             case XK_Up:
-                *dir = UP;
+                *direction = 3;
                 break;
             case XK_Down:
-                *dir = DOWN;
+                *direction = 4;
                 break;
         }
+    }
 
     /* Déplace la tête en fonction de la direction */
-        if (*dir == LEFT) {
+    if (*direction == 1) {
-            snake[0].posx -= 1;
+        serpent->corps[0].x += TAILLE_CASE;
-        } else if (*dir == RIGHT) {
+    } else if (*direction == 2) {
-            snake[0].posx += 1;
+        serpent->corps[0].x -= TAILLE_CASE;
-        } else if (*dir == UP) {
+    } else if (*direction == 3) {
-            snake[0].posy -= 1;
+        serpent->corps[0].y -= TAILLE_CASE;
-        } else if (*dir == DOWN) {
+    } else if (*direction == 4) {
-            snake[0].posy += 1;
+        serpent->corps[0].y += TAILLE_CASE;
-        }
-    }
     }
 
-/* Fonction pour gérer le mouvement du corps du serpent */
+    for (i = 0; i < serpent->longueur; i++) {
-void mouvementCorps(SnakePoint *snake, int taille) {
+        ChoisirCouleurDessin(s);
-    /* Déplace le corps du serpent en suivant la tête */
+        RemplirRectangle(serpent->corps[i].x, serpent->corps[i].y, TAILLE_CASE, TAILLE_CASE);
-    for (int i = taille - 1; i > 0; i--) {
-        snake[i] = snake[i - 1];
-    }
     }
 
-/* Fonction pour gérer les collisions */
+    Attendre(100);
-int gererCollisions(SnakePoint *snake, int *taille, SnakePoint *pommes) {
-    /* Vérifie la collision avec la pomme */
-    for (int i = 0; i < 5; i++) {
-        if (snake[0].posx == pommes[i].posx && snake[0].posy == pommes[i].posy) {
-            /* Augmente la taille du serpent */
-            *taille += 1;
-            pommes[i].posx = (rand() % (LARGEUR - 2)) + 1;
-            pommes[i].posy = (rand() % (HAUTEUR - 2)) + 1;
-            return 1; /* Collision avec une pomme */
-        }
-    }
-
-    /* Vérifie la collision avec la paroi intérieure du rectangle */
-    if (snake[0].posx <= 0 || snake[0].posx >= LARGEUR - 1 || snake[0].posy <= 0 || snake[0].posy >= HAUTEUR - 1) {
-        return -1; // Collision avec la paroi
-    }
-
-    return 0; // Pas de collision
 }
 
 int main() {
-    /* Initialisation du jeu */
+    int touche, go_on = 1, direction = 1;
-    graphique();
+    Serpent serpent;
-    SnakePoint snake[LARGEUR * HAUTEUR];
+    Pomme pommes[NOMBRE_POMMES];
-    SnakePoint pommes[5];
+    couleur c;
-    int taille = 1;
+    couleur v;
-    int dir;
+    couleur s;
-
     srand(time(NULL));
 
-    /* Position initiale du serpent au milieu du tableau */
+    Graphique();
-    snake[0].posx = LARGEUR / 2;
+    InitialiserGraphique();
-    snake[0].posy = HAUTEUR / 2;
+    CreerFenetre(10, 10, 1200, 820);
-
+    c = CouleurParNom("black");
-    graphique();
+    s = CouleurParNom("yellow");
-    AffichageBasique();
+    v = CouleurParNom("green");
+    EffacerEcran(c);
+ for (int i = 0; i < serpent.longueur; i++) {
+        serpent.corps[i].x = LARGEUR / 2;
+        serpent.corps[i].y = HAUTEUR / 2;
+    }
+    serpent.longueur = 10;
+    serpent.corps = malloc(sizeof(Segment) * serpent.longueur);
+    EcranJeu();
     genererPommes(pommes);
+    afficherSerpent(serpent);
 
-    unsigned long suivant = Microsecondes() + CYCLE;
+    while (go_on) {
-    int perdu = 0;
+        gestionCollision(&serpent, pommes);
-    int temps[2] = {0, 0}, seconde_actuel, old_seconde;
+        deplacerSerpent(&serpent, &direction);
-
-    while (!perdu) {
-        /* Calcul du temps */
-        if (Microsecondes() > suivant) {
-            suivant = Microsecondes() + CYCLE;
-            seconde_actuel = (suivant / 1000000) % 10;
-            if (seconde_actuel != old_seconde) {
-                old_seconde = seconde_actuel;
-                if ((temps[1] + 1) == 60) {
-                    temps[0]++;
-                    temps[1] = 0;
-                } else {
-                    temps[1]++;
-                }
-                /* Affichage du temps */
-                AfficheTemps(temps[0], temps[1]);
-            }
-
-            /* Déplacement du serpent */
-            mouvementTete(snake, &dir);
-            mouvementCorps(snake, taille);
-            perdu = gererCollisions(snake, &taille, pommes);
-            serpent(snake, taille);
-
-            /* Génération de nouvelles pommes si le serpent en a mangé une */
-            if (perdu == 1) {
-                genererPommes(pommes);
-            }
-        }
-    }
-
-    if (perdu == -1) {
-        printf("Vous avez perdu ! Collision avec la paroi.\n");
-    } else {
-        printf("Vous avez perdu ! Collision avec une pomme.\n");
     }
 
+    Touche();
     FermerGraphique();
-
     return EXIT_SUCCESS;
 }

snake.c

@@ -1,23 +1,27 @@
 #include <stdlib.h>
-#include <stdio.h>
 #include <graph.h>
 #include <time.h>
+#include <stdio.h>
 
 #define HAUTEUR 40
 #define LARGEUR 60
-#define CYCLE 100000L
 #define TAILLE_CASE 20
+#define ESPACE_HAUT 35
+#define ESPACE_BAS 85
+#define NOMBRE_POMMES 5
+#define CYCLE 100000L
 
-/* Enumeration des différentes directions possibles */
-enum Direction { UP = 2, DOWN = 3, LEFT = 0, RIGHT = 1 };
-
-/* Structure pour stocker les coordonnées des segments du serpent */
 typedef struct {
-    int posx, posy;
+    int x;
-} SnakePoint;
+    int y;
+} Segment;
+
+void Attendre(unsigned int millisecondes) {
+    usleep(millisecondes * 1000);
+}
 
 /* Fonction pour concevoir le graphique */
-void graphique() {
+void Graphique() {
     InitialiserGraphique();
     CreerFenetre(10, 10, 1240, 940);
     EcrireTexte(500, 400, "Le jeu va commencer !", 2);
@@ -27,159 +31,110 @@ void graphique() {
 
 void AffichageBasique() {
     ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
-    RemplirRectangle(10, 10, 1200, 820);
+    RemplirRectangle(10, 10, TAILLE_CASE * LARGEUR, TAILLE_CASE * LARGEUR);
 }
 
-void AfficheTemps(int minute, int seconde) {
+/* Fonction permettant d'afficher le serpent */
-    char temps[6];
+void afficherSerpent(Segment serpent[], int taille) {
-    snprintf(temps, 6, "%02d:%02d", minute, seconde);
+    int i;
-
+    couleur couleurSerpent = CouleurParComposante(255,255,0);
-    ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
+    ChoisirCouleurDessin(couleurSerpent);
-    RemplirRectangle(20, 870, 70, 40);
+    for (i = 0; i < 10; i++) {
-
+        serpent[i].x = LARGEUR / 2 + i * TAILLE_CASE;
-    ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
+        serpent[i].y = HAUTEUR / 2;
-    EcrireTexte(20, 900, temps, 2);
     }
-
+    for (i = 0; i < taille; i++) {
-/* Fonction pour afficher le serpent */
+        RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
-void serpent(SnakePoint *snake, int taille) {
-    for (int i = 0; i < taille; i++) {
-        couleur s = CouleurParComposante(255, 255, 0);
-        ChoisirCouleurDessin(s);
-        RemplirRectangle(snake[i].posx * TAILLE_CASE, snake[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
     }
 }
 
-/* Fonction pour générer les pommes */
+void genererPommes(Segment pommes[]) {
-void genererPommes(SnakePoint *pommes) {
+    for (int i = 0; i < NOMBRE_POMMES; i++) {
-    for (int i = 0; i < 5; i++) {
+        pommes[i].x = rand() % LARGEUR * TAILLE_CASE;
-        pommes[i].posx = rand() % LARGEUR;
+        pommes[i].y = rand() % HAUTEUR * TAILLE_CASE;
-        pommes[i].posy = rand() % HAUTEUR;
+        ChoisirCouleurDessin(CouleurParComposante(255, 0, 0));
-        couleur p = CouleurParComposante(255, 0, 0);
+	RemplirRectangle(pommes[i].x * TAILLE_CASE, pommes[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
-        ChoisirCouleurDessin(p);
-        RemplirRectangle(pommes[i].posx * TAILLE_CASE, pommes[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
     }
 }
 
-/* Fonction pour gérer le mouvement de la tête du serpent */
+void deplacerSerpent(int longueurSerpent, Segment serpent[], int *direction) {
-void mouvementTete(SnakePoint *snake, int *taille, int *dir) {
+    int i;
-    /* Déplace la tête en fonction de la direction */
+    couleur c;
+    couleur v;
+    couleur s;
+    c = CouleurParComposante(0,0,0);
+    s = CouleurParComposante(255,255,0);
+    v = CouleurParComposante(111,255,94);
+
+    for (i = 0; i < longueurSerpent; i++) {
+        ChoisirCouleurDessin(v);
+        RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
+    }
+    for (i = longueurSerpent - 1; i > 0; i--) {
+        serpent[i] = serpent[i - 1];
+    }
+    
     if (ToucheEnAttente()) {
         int touche = Touche();
         switch (touche) {
-            case XK_Left:
-                *dir = LEFT;
-                break;
             case XK_Right:
-                *dir = RIGHT;
+                *direction = 1;
+                break;
+            case XK_Left:
+                *direction = 2;
                 break;
             case XK_Up:
-                *dir = UP;
+                *direction = 3;
                 break;
             case XK_Down:
-                *dir = DOWN;
+                *direction = 4;
                 break;
         }
-
+    }
     /* Déplace la tête en fonction de la direction */
-        if (*dir == LEFT) {
+    if (*direction == 1) {
-            snake[0].posx -= 1;
+        serpent[0].x += TAILLE_CASE;
-        } else if (*dir == RIGHT) {
+    } else if (*direction == 2) {
-            snake[0].posx += 1;
+        serpent[0].x -= TAILLE_CASE;
-        } else if (*dir == UP) {
+    } else if (*direction == 3) {
-            snake[0].posy -= 1;
+        serpent[0].y -= TAILLE_CASE;
-        } else if (*dir == DOWN) {
+    } else if (*direction == 4) {
-            snake[0].posy += 1;
+        serpent[0].y += TAILLE_CASE;
-        }
-    }
     }
 
-/* Fonction pour gérer le mouvement du corps du serpent */
+    for (i = 0; i < longueurSerpent; i++) {
-void mouvementCorps(SnakePoint *snake, int taille) {
+        ChoisirCouleurDessin(s);
-    /* Déplace le corps du serpent en suivant la tête */
+        RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
-    for (int i = taille - 1; i > 0; i--) {
-        snake[i] = snake[i - 1];
     }
+    Attendre(100);
 }
 
-/* Fonction pour gérer les collisions */
-void gererCollisions(SnakePoint *snake, int *taille, SnakePoint *pommes) {
-    /* Vérifie la collision avec la pomme */
-    for (int i = 0; i < 5; i++) {
-        if (snake[0].posx == pommes[i].posx && snake[0].posy == pommes[i].posy) {
-            /* Augmente la taille du serpent */
-            *taille += 1;
-            /* Déplace la pomme hors de l'écran (elle disparaît) */
-            pommes[i].posx = -1;
-            pommes[i].posy = -1;
-        }
-	 /* Vérifie la collision avec la paroi intérieure du rectangle */
-    if (snake[0].posx <= 0 || snake[0].posx >= LARGEUR - 1 || snake[0].posy <= 0 || snake[0].posy >= HAUTEUR - 1) {
-        return -1; // Collision avec la paroi
-    }
-
-    return 0; // Pas de collision
-    }
-}
 
 int main() {
-    /* Initialisation du jeu */
+    int touche, perdu = 0, i, j, x = 0, direction = 1, longueurSerpent = 10;
-    graphique();
+    Segment serpent[LARGEUR * HAUTEUR];
-    SnakePoint snake[LARGEUR * HAUTEUR];
+    Segment pommes[NOMBRE_POMMES];
-    SnakePoint pommes[5];
+    couleur c = CouleurParComposante(0,0,0);
-    int taille = 1;
+    couleur v = CouleurParComposante(111,255,94);
-    int dir;
+    couleur s = CouleurParComposante(255,255,0);
-
     srand(time(NULL));
 
        /* Position initiale du serpent au milieu du tableau */
-    snake[0].posx = LARGEUR / 2;
+    serpent[0].x = LARGEUR / 2 * TAILLE_CASE;
-    snake[0].posy = HAUTEUR / 2;
+    serpent[0].y = HAUTEUR / 2 * TAILLE_CASE;
 
-    graphique();
+    
+    Graphique();
+    EffacerEcran(c);
     AffichageBasique();
     genererPommes(pommes);
+    afficherSerpent(serpent, longueurSerpent);
 
-    unsigned long suivant = Microsecondes() + CYCLE;
+    while (perdu!=-1) {
-    int temps[2] = {0, 0}, seconde_actuel, old_seconde;
+      deplacerSerpent(longueurSerpent, serpent, &direction);
-
-    while (1) {
-        /* Calcul du temps */
-        if (Microsecondes() > suivant) {
-            suivant = Microsecondes() + CYCLE;
-            seconde_actuel = (suivant / 1000000) % 10;
-            if (seconde_actuel != old_seconde) {
-                old_seconde = seconde_actuel;
-                if ((temps[1] + 1) == 60) {
-                    temps[0]++;
-                    temps[1] = 0;
-                } else {
-                    temps[1]++;
-                }
-                /* Affichage du temps */
-                AfficheTemps(temps[0], temps[1]);
-            }
-
-            /* Déplacement du serpent */
-            mouvementTete(snake, &taille, &dir);
-            mouvementCorps(snake, taille);
-            gererCollisions(snake, &taille, pommes);
-            serpent(snake, taille);
-
-            /* Génération de nouvelles pommes si le serpent en a mangé une */
-            for (int i = 0; i < 5; i++) {
-                if (pommes[i].posx == -1 && pommes[i].posy == -1) {
-                    pommes[i].posx = rand() % LARGEUR;
-                    pommes[i].posy = rand() % HAUTEUR;
-                    couleur p = CouleurParComposante(255, 0, 0);
-                    ChoisirCouleurDessin(p);
-                    RemplirRectangle(pommes[i].posx * TAILLE_CASE, pommes[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
-                }
-            }
-        }
     }
 
+    Touche();
     FermerGraphique();
-
     return EXIT_SUCCESS;
 }

test.c

@@ -6,15 +6,29 @@
 #define HAUTEUR 40
 #define LARGEUR 60
 #define CYCLE 100000L
+#define SEGMENT 10
+#define NOMBRE_POMMES 5
 #define TAILLE_CASE 20
+#define TAILLE_SERPENT 10
 
 /* Enumeration des différentes directions possibles */
-enum Direction { UP = 2, DOWN = 3, LEFT = 0, RIGHT = 1 };
+enum Direction { UP = 2, DOWN = 3, LEFT = 1, RIGHT = 2 }; 
 
-/* Structure pour stocker les coordonnées des segments du serpent */
 typedef struct {
-    int posx, posy;
+    int x, y;
-} SnakePoint;
+} Position;
+
+typedef struct {
+    Position* corps;
+    int longueur;
+} Serpent;
+
+typedef struct {
+    Position pomme;
+} Pomme;
+
+Serpent serpent;
+Pomme pommes[NOMBRE_POMMES];
 
 /* Fonction pour concevoir le graphique */
 void graphique() {
@@ -27,7 +41,7 @@ void graphique() {
 
 void AffichageBasique() {
     ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
-    RemplirRectangle(10, 10, 1200, 820);
+    RemplirRectangle(10, 10, TAILLE_CASE * LARGEUR, TAILLE_CASE * LARGEUR);
 }
 
 void AfficheTemps(int minute, int seconde) {
@@ -41,111 +55,126 @@ void AfficheTemps(int minute, int seconde) {
     EcrireTexte(20, 900, temps, 2);
 }
 
-/* Fonction pour afficher le serpent */
+void genererPommes() {
-void serpent(SnakePoint *snake, int taille) {
+    for (int i = 0; i < NOMBRE_POMMES; i++) {
-    for (int i = 0; i < taille; i++) {
+        pommes[i].pomme.x = rand() % (LARGEUR);
-        couleur s = CouleurParComposante(255, 255, 0);
+        pommes[i].pomme.y = rand() % (HAUTEUR);
-        ChoisirCouleurDessin(s);
+
-        RemplirRectangle(snake[i].posx * TAILLE_CASE, snake[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
+        ChoisirCouleurDessin(CouleurParComposante(255, 0, 0));
+        RemplirRectangle(pommes[i].pomme.x * TAILLE_CASE, pommes[i].pomme.y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
     }
 }
 
-/* Fonction pour générer les pommes */
+/*Fonction permettant d'afficher le serpent*/
-void genererPommes(SnakePoint *pommes) {
+void AffichageSerpent(Segment serpent[], int taille) {
-    for (int i = 0; i < 5; i++) {
+    int i;
-        pommes[i].posx = rand() % LARGEUR;
+    couleur couleurSerpent = CouleurParComposante(0,0,220);
-        pommes[i].posy = rand() % HAUTEUR;
+    ChoisirCouleurDessin(couleurSerpent);
-        couleur p = CouleurParComposante(255, 0, 0);
+    for (i = 0; i < 10; i++) {
-        ChoisirCouleurDessin(p);
+        serpent[i].x = LARGEUR / 2 + i * TAILLE_CASE;
-        RemplirRectangle(pommes[i].posx * TAILLE_CASE, pommes[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
+        serpent[i].y = HAUTEUR  / 2;
+    }
+    for (i = 0; i < taille; i++) {
+        RemplirRectangle(serpent[i].x , serpent[i].y, TAILLE_CASE, TAILLE_CASE);
     }
 }
 
-/* Fonction pour gérer le mouvement de la tête du serpent */
+int collisionAvecPomme(Position *pomme) {
-void mouvementTete(SnakePoint *snake, int *dir) {
+    return (serpent.corps[0].x == pomme->x && serpent.corps[0].y == pomme->y);
-    /* Déplace la tête en fonction de la direction */
-    if (ToucheEnAttente()) {
-        int touche = Touche();
-        switch (touche) {
-            case XK_Left:
-                *dir = LEFT;
-                break;
-            case XK_Right:
-                *dir = RIGHT;
-                break;
-            case XK_Up:
-                *dir = UP;
-                break;
-            case XK_Down:
-                *dir = DOWN;
-                break;
 }
 
-        /* Déplace la tête en fonction de la direction */
+int collisionAvecSerpent() {
-        if (*dir == LEFT) {
+    for (int i = 1; i < serpent.longueur; i++) {
-            snake[0].posx -= 1;
+        if (serpent.corps[0].x == serpent.corps[i].x && serpent.corps[0].y == serpent.corps[i].y) {
-        } else if (*dir == RIGHT) {
-            snake[0].posx += 1;
-        } else if (*dir == UP) {
-            snake[0].posy -= 1;
-        } else if (*dir == DOWN) {
-            snake[0].posy += 1;
-        }
-    }
-}
-
-/* Fonction pour gérer le mouvement du corps du serpent */
-void mouvementCorps(SnakePoint *snake, int taille) {
-    /* Déplace le corps du serpent en suivant la tête */
-    for (int i = taille - 1; i > 0; i--) {
-        snake[i] = snake[i - 1];
-    }
-}
-
-/* Fonction pour gérer les collisions */
-int gererCollisions(SnakePoint *snake, int *taille, SnakePoint *pommes) {
-    /* Vérifie la collision avec la pomme */
-    for (int i = 0; i < 5; i++) {
-        if (snake[0].posx == pommes[i].posx && snake[0].posy == pommes[i].posy) {
-            /* Augmente la taille du serpent */
-            *taille += 1;
-            pommes[i].posx = (rand() % (LARGEUR - 2)) + 1;
-            pommes[i].posy = (rand() % (HAUTEUR - 2)) + 1;
             return 1;
-      /* Le serpent a mangé une pomme une pomme */
+        }
+    }
+    return 0;
+}
+
+int collisionAvecBordures() {
+    return (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR ||
+            serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR);
+}
+
+void gestionCollision() {
+    for (int i = 0; i < NOMBRE_POMMES; i++) {
+        if (collisionAvecPomme(&(pommes[i].pomme))) {
+            serpent.longueur++;
+            serpent.corps = realloc(serpent.corps, sizeof(Position) * serpent.longueur);
+            genererPommes();
         }
     }
 
-    /* Vérifie la collision avec la paroi intérieure du rectangle */
+    if (collisionAvecSerpent() || collisionAvecBordures()) {
-    if (snake[0].posx <= 0 || snake[0].posx >= LARGEUR - 1 || snake[0].posy <= 0 || snake[0].posy >= HAUTEUR - 1) {
+        FermerGraphique();
-        return -1; // Collision avec la paroi
+        exit(EXIT_SUCCESS);
+    }
 }
 
-    return 0; // Pas de collision
+/* Fonction pour gérer le mouvement du serpent */
+void mouvementSerpent(int dir) {
+    /* Déplace le corps du serpent en suivant la tête */
+    for (int i = serpent.longueur - 1; i > 0; i--) {
+        serpent.corps[i] = serpent.corps[i - 1];
+    }
+
+    /* Déplace la tête en fonction de la direction */
+    if (dir == LEFT) {
+        serpent.corps[0].x -= 1;
+    } else if (dir == RIGHT) {
+        serpent.corps[0].x += 1;
+    } else if (dir == UP) {
+        serpent.corps[0].y -= 1;
+    } else if (dir == DOWN) {
+        serpent.corps[0].y += 1;
+    }
+
+    /* Affichage du serpent */
+    for (int i = 0; i < serpent.longueur; i++) {
+        ChoisirCouleurDessin(CouleurParComposante(0, 255, 0));
+        RemplirRectangle(serpent.corps[i].x * TAILLE_CASE, serpent.corps[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
+    }
 }
 
 int main() {
     /* Initialisation du jeu */
-    graphique();
-    SnakePoint snake[LARGEUR * HAUTEUR];
-    SnakePoint pommes[5];
-    int taille = 1;
-    int dir;
-
-    srand(time(NULL));
-
-    /* Position initiale du serpent au milieu du tableau */
-    snake[0].posx = LARGEUR / 2;
-    snake[0].posy = HAUTEUR / 2;
-
     graphique();
     AffichageBasique();
+    srand(time(NULL));  // Initialisation de la graine pour rand()
+    serpent.longueur = TAILLE_SERPENT;
+    serpent.corps = malloc(sizeof(Position) * serpent.longueur);
+
+    for (int i = 0; i < serpent.longueur; i++) {
+        serpent.corps[i].x = LARGEUR / 2;
+        serpent.corps[i].y = HAUTEUR / 2;
+    }
+
+    genererPommes();
 
     unsigned long suivant = Microsecondes() + CYCLE;
-    int perdu = 0;
+    int dir = RIGHT; /* Direction initiale vers la droite */
     int temps[2] = {0, 0}, seconde_actuel, old_seconde;
 
-    while (!perdu) {
+    while (1) {
+        if (ToucheEnAttente()) {
+            int touche = Touche();
+            switch (touche) {
+                case XK_Left:
+                    dir = LEFT;
+                    break;
+                case XK_Right:
+                    dir = RIGHT;
+                    break;
+                case XK_Up:
+                    dir = UP;
+                    break;
+                case XK_Down:
+                    dir = DOWN;
+                    break;
+            }
+        }
+
         /* Calcul du temps */
         if (Microsecondes() > suivant) {
             suivant = Microsecondes() + CYCLE;
@@ -162,26 +191,13 @@ int main() {
                 AfficheTemps(temps[0], temps[1]);
             }
 
-            /* Déplacement du serpent */
+            mouvementSerpent(dir);
-            mouvementTete(snake, &dir);
+            gestionCollision();
-            mouvementCorps(snake, taille);
+            ActualiserGraphique();
-            perdu = gererCollisions(snake, &taille, pommes);
+            usleep(CYCLE);
-            serpent(snake, taille);
-
-            /* Génération de nouvelles pommes si le serpent en a mangé une */
-            if (perdu == 1) {
-                genererPommes(pommes);
         }
     }
-    }
-
-    if (perdu == -1) {
-        printf("Vous avez perdu ! Collision avec la paroi.\n");
-    } else if(perdu == 1){
-      
-    }
 
     FermerGraphique();
-
     return EXIT_SUCCESS;
 }