From a5c4d48b2d5d955fb1b072baa5fffdb7eb7ac95a Mon Sep 17 00:00:00 2001 From: rognant Date: Sat, 9 Dec 2023 15:34:02 +0100 Subject: [PATCH] T --- essai.c | 168 ++++++++++++++++++++++++++++++++ essai.c~ | 169 ++++++++++++++++++++++++++++++++ final.c | 68 ------------- graphique.c | 60 ------------ idée.c | 132 ------------------------- jeu.c | 189 ------------------------------------ jeu.c~ | 0 serpent.c | 274 ++++++++++++++++++++++++++-------------------------- serpent.c~ | 0 snake.c | 217 +++++++++++++++++------------------------ test.c | 218 ++++++++++++++++++++++------------------- 11 files changed, 678 insertions(+), 817 deletions(-) create mode 100644 essai.c create mode 100644 essai.c~ delete mode 100644 final.c delete mode 100644 graphique.c delete mode 100644 idée.c delete mode 100644 jeu.c delete mode 100644 jeu.c~ delete mode 100644 serpent.c~ diff --git a/essai.c b/essai.c new file mode 100644 index 0000000..87c02a0 --- /dev/null +++ b/essai.c @@ -0,0 +1,168 @@ +#include +#include +#include +#include +#include + +#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; +} diff --git a/essai.c~ b/essai.c~ new file mode 100644 index 0000000..f3cd78a --- /dev/null +++ b/essai.c~ @@ -0,0 +1,169 @@ +#include +#include +#include +#include // Ajout de l'en-tête pour usleep +#include + +#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; +} diff --git a/final.c b/final.c deleted file mode 100644 index 592e3d9..0000000 --- a/final.c +++ /dev/null @@ -1,68 +0,0 @@ -#include -#include -#include -#include -#include - -#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; - } - - - - - - - - - - - diff --git a/graphique.c b/graphique.c deleted file mode 100644 index f9566ca..0000000 --- a/graphique.c +++ /dev/null @@ -1,60 +0,0 @@ -#include -#include -#include -#include - -#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;isuivant){ - n++; - graphique(); - suivant= Microseconde()+CYCLE; - } - } - - - - - return EXIT_SUCCESS; -} - - - diff --git a/idée.c b/idée.c deleted file mode 100644 index 52dc90e..0000000 --- a/idée.c +++ /dev/null @@ -1,132 +0,0 @@ -#include -#include -#include -#include - -#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; -} diff --git a/jeu.c b/jeu.c deleted file mode 100644 index dd9d665..0000000 --- a/jeu.c +++ /dev/null @@ -1,189 +0,0 @@ -#include -#include -#include -#include - -#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; -} diff --git a/jeu.c~ b/jeu.c~ deleted file mode 100644 index e69de29..0000000 diff --git a/serpent.c b/serpent.c index eda0a20..2c8b276 100644 --- a/serpent.c +++ b/serpent.c @@ -1,23 +1,35 @@ #include -#include #include #include +#include #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; -} SnakePoint; + int x; + 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() { - ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); - RemplirRectangle(10, 10, 1200, 820); -} +/* Fonction permettant d'afficher le serpent */ +void afficherSerpent(Serpent serpent) { + couleur couleurSerpent = CouleurParNom("yellow"); + ChoisirCouleurDessin(couleurSerpent); -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); + for (int i = 0; i < serpent.longueur; i++) { + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, 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; - 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); +void genererPommes(Pomme 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 gérer le mouvement de la tête du serpent */ -void mouvementTete(SnakePoint *snake, int *dir) { - /* Déplace la tête en fonction de la direction */ +/* Fonction initialisant la fenetre de jeux en vert */ +void EcranJeu() { + 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) { - 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, 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 + /* Déplace la tête en fonction de la direction */ + if (*direction == 1) { + serpent->corps[0].x += TAILLE_CASE; + } else if (*direction == 2) { + serpent->corps[0].x -= TAILLE_CASE; + } else if (*direction == 3) { + serpent->corps[0].y -= TAILLE_CASE; + } else if (*direction == 4) { + serpent->corps[0].y += TAILLE_CASE; } - return 0; // Pas de collision + for (i = 0; i < serpent->longueur; i++) { + ChoisirCouleurDessin(s); + RemplirRectangle(serpent->corps[i].x, serpent->corps[i].y, TAILLE_CASE, TAILLE_CASE); + } + + Attendre(100); } int main() { - /* Initialisation du jeu */ - graphique(); - SnakePoint snake[LARGEUR * HAUTEUR]; - SnakePoint pommes[5]; - int taille = 1; - int dir; - + int touche, go_on = 1, direction = 1; + Serpent serpent; + Pomme pommes[NOMBRE_POMMES]; + couleur c; + couleur v; + couleur s; srand(time(NULL)); - /* Position initiale du serpent au milieu du tableau */ - snake[0].posx = LARGEUR / 2; - snake[0].posy = HAUTEUR / 2; - - graphique(); - AffichageBasique(); + Graphique(); + InitialiserGraphique(); + CreerFenetre(10, 10, 1200, 820); + c = CouleurParNom("black"); + s = CouleurParNom("yellow"); + 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; - 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, &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"); + while (go_on) { + gestionCollision(&serpent, pommes); + deplacerSerpent(&serpent, &direction); } + Touche(); FermerGraphique(); - return EXIT_SUCCESS; } diff --git a/serpent.c~ b/serpent.c~ deleted file mode 100644 index e69de29..0000000 diff --git a/snake.c b/snake.c index 6211de9..c3681b2 100644 --- a/snake.c +++ b/snake.c @@ -1,23 +1,27 @@ #include -#include #include #include +#include #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; -} SnakePoint; + int x; + 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) { - 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 permettant d'afficher le serpent */ +void afficherSerpent(Segment serpent[], int taille) { + int i; + couleur couleurSerpent = CouleurParComposante(255,255,0); + ChoisirCouleurDessin(couleurSerpent); + for (i = 0; i < 10; i++) { + serpent[i].x = LARGEUR / 2 + i * 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énérer les pommes */ -void genererPommes(SnakePoint *pommes) { - for (int i = 0; i < 5; i++) { - 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); +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 * TAILLE_CASE, pommes[i].y * 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 *dir) { - /* Déplace la tête en fonction de la direction */ +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_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) { - 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; - } } + /* 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 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 */ -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 */ - graphique(); - SnakePoint snake[LARGEUR * HAUTEUR]; - SnakePoint pommes[5]; - int taille = 1; - int dir; - + int touche, perdu = 0, i, j, x = 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 */ - snake[0].posx = LARGEUR / 2; - snake[0].posy = HAUTEUR / 2; + /* Position initiale du serpent au milieu du tableau */ + serpent[0].x = LARGEUR / 2 * TAILLE_CASE; + serpent[0].y = HAUTEUR / 2 * TAILLE_CASE; - graphique(); + + Graphique(); + EffacerEcran(c); AffichageBasique(); genererPommes(pommes); + afficherSerpent(serpent, longueurSerpent); - unsigned long suivant = Microsecondes() + CYCLE; - int temps[2] = {0, 0}, seconde_actuel, old_seconde; - - 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); - } - } - } + while (perdu!=-1) { + deplacerSerpent(longueurSerpent, serpent, &direction); } + Touche(); FermerGraphique(); - return EXIT_SUCCESS; } diff --git a/test.c b/test.c index cda652b..f2744f9 100644 --- a/test.c +++ b/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; -} SnakePoint; + int x, y; +} 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 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); +void genererPommes() { + for (int i = 0; i < NOMBRE_POMMES; i++) { + pommes[i].pomme.x = rand() % (LARGEUR); + pommes[i].pomme.y = rand() % (HAUTEUR); + + 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 */ -void genererPommes(SnakePoint *pommes) { - for (int i = 0; i < 5; i++) { - 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); +/*Fonction permettant d'afficher le serpent*/ +void AffichageSerpent(Segment serpent[], int taille) { + int i; + couleur couleurSerpent = CouleurParComposante(0,0,220); + ChoisirCouleurDessin(couleurSerpent); + for (i = 0; i < 10; i++) { + serpent[i].x = LARGEUR / 2 + i * 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 */ -void mouvementTete(SnakePoint *snake, 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; - } +int collisionAvecPomme(Position *pomme) { + return (serpent.corps[0].x == pomme->x && serpent.corps[0].y == pomme->y); +} - /* 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; +int collisionAvecSerpent() { + 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; } -/* Fonction pour gérer le mouvement du corps du serpent */ -void mouvementCorps(SnakePoint *snake, int taille) { +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(); + } + } + + if (collisionAvecSerpent() || collisionAvecBordures()) { + FermerGraphique(); + exit(EXIT_SUCCESS); + } +} + +/* 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 = 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 */ - } + for (int i = serpent.longueur - 1; i > 0; i--) { + serpent.corps[i] = serpent.corps[i - 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 + /* 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; } - return 0; // Pas de collision + /* 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 */ - 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); - } + mouvementSerpent(dir); + gestionCollision(); + ActualiserGraphique(); + usleep(CYCLE); } } - if (perdu == -1) { - printf("Vous avez perdu ! Collision avec la paroi.\n"); - } else if(perdu == 1){ - - } - FermerGraphique(); - return EXIT_SUCCESS; }