From a5c4d48b2d5d955fb1b072baa5fffdb7eb7ac95a Mon Sep 17 00:00:00 2001 From: rognant Date: Sat, 9 Dec 2023 15:34:02 +0100 Subject: [PATCH 1/9] 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; } From 39e5aaa1d311bb05eb65b4a47e84bb4f70aa0c1b Mon Sep 17 00:00:00 2001 From: rognant Date: Mon, 11 Dec 2023 14:03:33 +0100 Subject: [PATCH 2/9] t --- essai.c | 168 ------------------------------ essai.c~ | 169 ------------------------------ serpent.c | 307 ++++++++++++++++++++++++++++++++++++------------------ snake.c | 286 ++++++++++++++++++++++++++++++++++++++------------ test.c | 203 ------------------------------------ 5 files changed, 430 insertions(+), 703 deletions(-) delete mode 100644 essai.c delete mode 100644 essai.c~ delete mode 100644 test.c diff --git a/essai.c b/essai.c deleted file mode 100644 index 87c02a0..0000000 --- a/essai.c +++ /dev/null @@ -1,168 +0,0 @@ -#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~ deleted file mode 100644 index f3cd78a..0000000 --- a/essai.c~ +++ /dev/null @@ -1,169 +0,0 @@ -#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/serpent.c b/serpent.c index 2c8b276..29484b9 100644 --- a/serpent.c +++ b/serpent.c @@ -2,44 +2,101 @@ #include #include #include +#include #define HAUTEUR 40 #define LARGEUR 60 -#define TAILLE_CASE 20 +#define TAILLE_CASE 19 #define NOMBRE_POMMES 5 #define CYCLE 100000L typedef struct { int x; int y; -} Segment; - -typedef struct { - int x; - int y; -} Pomme; +} Position; typedef struct { + Position* corps; int longueur; - Segment* corps; } Serpent; +typedef struct { + Position* positions; + int nombre; +} Pommes; + +Serpent serpent; +Pommes pommes; +int score = 0; // Ajout de la variable score + +int perdu = 0; // Variable pour indiquer si le serpent a perdu + void Attendre(unsigned int millisecondes) { usleep(millisecondes * 1000); } -/* Fonction pour concevoir le graphique */ +void InitialiserJeu() { + serpent.longueur = 10; + serpent.corps = malloc(sizeof(Position) * serpent.longueur); + pommes.nombre = NOMBRE_POMMES; + + srand(time(NULL)); + + serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE; + serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE; + perdu = 0; // Initialisation de la variable perdu +} + void Graphique() { InitialiserGraphique(); - CreerFenetre(10, 10, 1240, 940); + CreerFenetre(1, 1, 1240, 940); EcrireTexte(500, 400, "Le jeu va commencer !", 2); - sleep(1); + Attendre(1000); EffacerEcran(CouleurParComposante(0, 0, 0)); } -/* Fonction permettant d'afficher le serpent */ -void afficherSerpent(Serpent serpent) { - couleur couleurSerpent = CouleurParNom("yellow"); +void AffichageBasique() { + ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); + RemplirRectangle(0, 0, 1175, 775); +} + +void AfficherScore() { + char scoreText[20]; // Correction de la taille du tableau + snprintf(scoreText, 20, "Score: %d", score); + ChoisirCouleurDessin(CouleurParComposante(0, 0, 0)); + RemplirRectangle(20, 820, 150, 40); + ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); + EcrireTexte(20, 850, scoreText, 2); +} + +int PauseJeu() { + while (1) { + if (ToucheEnAttente()) { + int touche = Touche(); + if (touche == XK_space) { + return 1; // La barre d'espace a été pressée, reprendre le jeu + } + } + Attendre(100); + } +} + +void LibererMemoire() { + free(serpent.corps); + free(pommes.positions); +} + +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); +} + +void AfficherSerpent() { + couleur couleurSerpent = CouleurParComposante(255, 255, 0); ChoisirCouleurDessin(couleurSerpent); for (int i = 0; i < serpent.longueur; i++) { @@ -47,72 +104,74 @@ void afficherSerpent(Serpent serpent) { } } -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); +void GenererPommes() { + couleur couleurPommes = CouleurParComposante(255, 0, 0); + pommes.positions = malloc(sizeof(Position) * pommes.nombre); + + for (int i = 0; i < pommes.nombre; i++) { + pommes.positions[i].x = rand() % LARGEUR; + pommes.positions[i].y = rand() % HAUTEUR; + ChoisirCouleurDessin(couleurPommes); + RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); } } -/* 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); - } - } +void GenererNouvellePomme() { + couleur couleurPommes = CouleurParComposante(255, 0, 0); + int i = rand() % pommes.nombre; // Utilisation d'une position aléatoire + pommes.positions[i].x = rand() % LARGEUR; + pommes.positions[i].y = rand() % HAUTEUR; + ChoisirCouleurDessin(couleurPommes); + RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * 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) { +int CollisionAvecPomme() { + for (int i = 0; i < pommes.nombre; i++) { + /* Vérifier si la tête du serpent est à l'intérieur de la zone de la pomme*/ + if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE && + serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE && + serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE && + serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) { + GenererNouvellePomme(); // Générer une nouvelle position pour la pomme mangée + score= score +5; // Augmenter le score + AfficherScore(); // Mettre à jour l'affichage du score 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); +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) { + perdu = -1; // Le serpent a perdu + return 1; + } } + return 0; } -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); +int CollisionAvecBordures() { + if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE || + serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) { + perdu = -1; // Le serpent a perdu + return 1; } - for (i = serpent->longueur - 1; i > 0; i--) { - serpent->corps[i] = serpent->corps[i - 1]; + return 0; +} + +void DeplacerSerpent(int* direction) { + couleur couleurFond = CouleurParComposante(0, 0, 0); + couleur couleurSerpent = CouleurParComposante(255, 255, 0); + couleur couleurTerrain = CouleurParComposante(111, 255, 94); + + for (int i = 0; i < serpent.longueur; i++) { + ChoisirCouleurDessin(couleurTerrain); + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); + } + + for (int i = serpent.longueur - 1; i > 0; i--) { + serpent.corps[i] = serpent.corps[i - 1]; } if (ToucheEnAttente()) { @@ -133,57 +192,107 @@ void deplacerSerpent(Serpent *serpent, int *direction) { } } - /* Déplace la tête en fonction de la direction */ if (*direction == 1) { - serpent->corps[0].x += TAILLE_CASE; + serpent.corps[0].x += TAILLE_CASE; } else if (*direction == 2) { - serpent->corps[0].x -= TAILLE_CASE; + serpent.corps[0].x -= TAILLE_CASE; } else if (*direction == 3) { - serpent->corps[0].y -= TAILLE_CASE; + serpent.corps[0].y -= TAILLE_CASE; } else if (*direction == 4) { - serpent->corps[0].y += TAILLE_CASE; + serpent.corps[0].y += TAILLE_CASE; } - for (i = 0; i < serpent->longueur; i++) { - ChoisirCouleurDessin(s); - RemplirRectangle(serpent->corps[i].x, serpent->corps[i].y, TAILLE_CASE, TAILLE_CASE); + for (int i = 0; i < serpent.longueur; i++) { + ChoisirCouleurDessin(couleurSerpent); + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); } Attendre(100); } +int GestionCollision(int perdu) { + int loose = perdu; + if (CollisionAvecPomme()) { + serpent.longueur = serpent.longueur +2; + serpent.corps = realloc(serpent.corps, sizeof(Position) * serpent.longueur); + loose = 1; + } + if (CollisionAvecSerpent() || CollisionAvecBordures()) { + loose = -1; /* Le serpent a perdu*/ + } + printf("%d \n", loose); + return loose; +} + int main() { - int touche, go_on = 1, direction = 1; - Serpent serpent; - Pomme pommes[NOMBRE_POMMES]; - couleur c; - couleur v; - couleur s; - srand(time(NULL)); + int direction = 1; + unsigned long suivant = Microsecondes() + CYCLE; + int temps[2] = {0, 0}, seconde_actuel, old_seconde; + int jeuEnPause = 0; + int perdu = 0; + InitialiserJeu(); 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); + EffacerEcran(CouleurParComposante(0, 0, 0)); + AffichageBasique(); + GenererPommes(); + AfficherSerpent(); + AfficherScore(); - while (go_on) { - gestionCollision(&serpent, pommes); - deplacerSerpent(&serpent, &direction); + while (perdu != -1) { + if (!jeuEnPause) { + 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]++; + } + AfficheTemps(temps[0], temps[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; + case XK_space: + jeuEnPause = 1; + break; + } + } + DeplacerSerpent(&direction); + perdu = GestionCollision(perdu); + if (perdu == 1) { + GenererNouvellePomme(); + perdu = 0; + } + } else { + // Le jeu est en pause + if (ToucheEnAttente()) { + int touche = Touche(); + if (touche == XK_space) { + jeuEnPause = 0; + } + } + } } - Touche(); FermerGraphique(); + LibererMemoire(); return EXIT_SUCCESS; } diff --git a/snake.c b/snake.c index c3681b2..29484b9 100644 --- a/snake.c +++ b/snake.c @@ -2,78 +2,178 @@ #include #include #include +#include #define HAUTEUR 40 #define LARGEUR 60 -#define TAILLE_CASE 20 -#define ESPACE_HAUT 35 -#define ESPACE_BAS 85 +#define TAILLE_CASE 19 #define NOMBRE_POMMES 5 #define CYCLE 100000L typedef struct { int x; int y; -} Segment; +} Position; + +typedef struct { + Position* corps; + int longueur; +} Serpent; + +typedef struct { + Position* positions; + int nombre; +} Pommes; + +Serpent serpent; +Pommes pommes; +int score = 0; // Ajout de la variable score + +int perdu = 0; // Variable pour indiquer si le serpent a perdu void Attendre(unsigned int millisecondes) { usleep(millisecondes * 1000); } -/* Fonction pour concevoir le graphique */ +void InitialiserJeu() { + serpent.longueur = 10; + serpent.corps = malloc(sizeof(Position) * serpent.longueur); + pommes.nombre = NOMBRE_POMMES; + + srand(time(NULL)); + + serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE; + serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE; + perdu = 0; // Initialisation de la variable perdu +} + void Graphique() { InitialiserGraphique(); - CreerFenetre(10, 10, 1240, 940); + CreerFenetre(1, 1, 1240, 940); EcrireTexte(500, 400, "Le jeu va commencer !", 2); - sleep(1); + Attendre(1000); EffacerEcran(CouleurParComposante(0, 0, 0)); } void AffichageBasique() { ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); - RemplirRectangle(10, 10, TAILLE_CASE * LARGEUR, TAILLE_CASE * LARGEUR); + RemplirRectangle(0, 0, 1175, 775); } -/* Fonction permettant d'afficher le serpent */ -void afficherSerpent(Segment serpent[], int taille) { - int i; - couleur couleurSerpent = CouleurParComposante(255,255,0); +void AfficherScore() { + char scoreText[20]; // Correction de la taille du tableau + snprintf(scoreText, 20, "Score: %d", score); + ChoisirCouleurDessin(CouleurParComposante(0, 0, 0)); + RemplirRectangle(20, 820, 150, 40); + ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); + EcrireTexte(20, 850, scoreText, 2); +} + +int PauseJeu() { + while (1) { + if (ToucheEnAttente()) { + int touche = Touche(); + if (touche == XK_space) { + return 1; // La barre d'espace a été pressée, reprendre le jeu + } + } + Attendre(100); + } +} + +void LibererMemoire() { + free(serpent.corps); + free(pommes.positions); +} + +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); +} + +void AfficherSerpent() { + 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); + + for (int i = 0; i < serpent.longueur; i++) { + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, 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); +void GenererPommes() { + couleur couleurPommes = CouleurParComposante(255, 0, 0); + pommes.positions = malloc(sizeof(Position) * pommes.nombre); + + for (int i = 0; i < pommes.nombre; i++) { + pommes.positions[i].x = rand() % LARGEUR; + pommes.positions[i].y = rand() % HAUTEUR; + ChoisirCouleurDessin(couleurPommes); + RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); } } -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); +void GenererNouvellePomme() { + couleur couleurPommes = CouleurParComposante(255, 0, 0); + int i = rand() % pommes.nombre; // Utilisation d'une position aléatoire + pommes.positions[i].x = rand() % LARGEUR; + pommes.positions[i].y = rand() % HAUTEUR; + ChoisirCouleurDessin(couleurPommes); + RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); +} - for (i = 0; i < longueurSerpent; i++) { - ChoisirCouleurDessin(v); - RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE); +int CollisionAvecPomme() { + for (int i = 0; i < pommes.nombre; i++) { + /* Vérifier si la tête du serpent est à l'intérieur de la zone de la pomme*/ + if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE && + serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE && + serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE && + serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) { + GenererNouvellePomme(); // Générer une nouvelle position pour la pomme mangée + score= score +5; // Augmenter le score + AfficherScore(); // Mettre à jour l'affichage du score + return 1; + } } - for (i = longueurSerpent - 1; i > 0; i--) { - serpent[i] = serpent[i - 1]; + return 0; +} + +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) { + perdu = -1; // Le serpent a perdu + return 1; + } } - + return 0; +} + +int CollisionAvecBordures() { + if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE || + serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) { + perdu = -1; // Le serpent a perdu + return 1; + } + return 0; +} + +void DeplacerSerpent(int* direction) { + couleur couleurFond = CouleurParComposante(0, 0, 0); + couleur couleurSerpent = CouleurParComposante(255, 255, 0); + couleur couleurTerrain = CouleurParComposante(111, 255, 94); + + for (int i = 0; i < serpent.longueur; i++) { + ChoisirCouleurDessin(couleurTerrain); + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); + } + + for (int i = serpent.longueur - 1; i > 0; i--) { + serpent.corps[i] = serpent.corps[i - 1]; + } + if (ToucheEnAttente()) { int touche = Touche(); switch (touche) { @@ -91,50 +191,108 @@ void deplacerSerpent(int longueurSerpent, Segment serpent[], int *direction) { break; } } - /* Déplace la tête en fonction de la direction */ + if (*direction == 1) { - serpent[0].x += TAILLE_CASE; + serpent.corps[0].x += TAILLE_CASE; } else if (*direction == 2) { - serpent[0].x -= TAILLE_CASE; + serpent.corps[0].x -= TAILLE_CASE; } else if (*direction == 3) { - serpent[0].y -= TAILLE_CASE; + serpent.corps[0].y -= TAILLE_CASE; } else if (*direction == 4) { - serpent[0].y += TAILLE_CASE; + serpent.corps[0].y += TAILLE_CASE; } - for (i = 0; i < longueurSerpent; i++) { - ChoisirCouleurDessin(s); - RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE); + for (int i = 0; i < serpent.longueur; i++) { + ChoisirCouleurDessin(couleurSerpent); + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); } + Attendre(100); } +int GestionCollision(int perdu) { + int loose = perdu; + if (CollisionAvecPomme()) { + serpent.longueur = serpent.longueur +2; + serpent.corps = realloc(serpent.corps, sizeof(Position) * serpent.longueur); + loose = 1; + } + if (CollisionAvecSerpent() || CollisionAvecBordures()) { + loose = -1; /* Le serpent a perdu*/ + } + printf("%d \n", loose); + return loose; +} int main() { - 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)); + int direction = 1; + unsigned long suivant = Microsecondes() + CYCLE; + int temps[2] = {0, 0}, seconde_actuel, old_seconde; + int jeuEnPause = 0; + int perdu = 0; - /* Position initiale du serpent au milieu du tableau */ - serpent[0].x = LARGEUR / 2 * TAILLE_CASE; - serpent[0].y = HAUTEUR / 2 * TAILLE_CASE; - - + InitialiserJeu(); Graphique(); - EffacerEcran(c); + EffacerEcran(CouleurParComposante(0, 0, 0)); AffichageBasique(); - genererPommes(pommes); - afficherSerpent(serpent, longueurSerpent); + GenererPommes(); + AfficherSerpent(); + AfficherScore(); - while (perdu!=-1) { - deplacerSerpent(longueurSerpent, serpent, &direction); + while (perdu != -1) { + if (!jeuEnPause) { + 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]++; + } + AfficheTemps(temps[0], temps[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; + case XK_space: + jeuEnPause = 1; + break; + } + } + DeplacerSerpent(&direction); + perdu = GestionCollision(perdu); + if (perdu == 1) { + GenererNouvellePomme(); + perdu = 0; + } + } else { + // Le jeu est en pause + if (ToucheEnAttente()) { + int touche = Touche(); + if (touche == XK_space) { + jeuEnPause = 0; + } + } + } } - Touche(); FermerGraphique(); + LibererMemoire(); return EXIT_SUCCESS; } diff --git a/test.c b/test.c deleted file mode 100644 index f2744f9..0000000 --- a/test.c +++ /dev/null @@ -1,203 +0,0 @@ -#include -#include -#include -#include - -#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 = 1, RIGHT = 2 }; - -typedef struct { - 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() { - 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, 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); -} - -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 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); - } -} - -int collisionAvecPomme(Position *pomme) { - return (serpent.corps[0].x == pomme->x && serpent.corps[0].y == pomme->y); -} - -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; -} - -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 = 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(); - 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 dir = RIGHT; /* Direction initiale vers la droite */ - int temps[2] = {0, 0}, seconde_actuel, old_seconde; - - 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; - 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]); - } - - mouvementSerpent(dir); - gestionCollision(); - ActualiserGraphique(); - usleep(CYCLE); - } - } - - FermerGraphique(); - return EXIT_SUCCESS; -} From 10211b3cd768142b89ca2b0550b9b0a1c8dcee52 Mon Sep 17 00:00:00 2001 From: rognant Date: Mon, 11 Dec 2023 14:16:26 +0100 Subject: [PATCH 3/9] t --- serpent.c | 298 ------------------------------------------------------ snake.c | 298 ------------------------------------------------------ 2 files changed, 596 deletions(-) delete mode 100644 serpent.c delete mode 100644 snake.c diff --git a/serpent.c b/serpent.c deleted file mode 100644 index 29484b9..0000000 --- a/serpent.c +++ /dev/null @@ -1,298 +0,0 @@ -#include -#include -#include -#include -#include - -#define HAUTEUR 40 -#define LARGEUR 60 -#define TAILLE_CASE 19 -#define NOMBRE_POMMES 5 -#define CYCLE 100000L - -typedef struct { - int x; - int y; -} Position; - -typedef struct { - Position* corps; - int longueur; -} Serpent; - -typedef struct { - Position* positions; - int nombre; -} Pommes; - -Serpent serpent; -Pommes pommes; -int score = 0; // Ajout de la variable score - -int perdu = 0; // Variable pour indiquer si le serpent a perdu - -void Attendre(unsigned int millisecondes) { - usleep(millisecondes * 1000); -} - -void InitialiserJeu() { - serpent.longueur = 10; - serpent.corps = malloc(sizeof(Position) * serpent.longueur); - pommes.nombre = NOMBRE_POMMES; - - srand(time(NULL)); - - serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE; - serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE; - perdu = 0; // Initialisation de la variable perdu -} - -void Graphique() { - InitialiserGraphique(); - CreerFenetre(1, 1, 1240, 940); - EcrireTexte(500, 400, "Le jeu va commencer !", 2); - Attendre(1000); - EffacerEcran(CouleurParComposante(0, 0, 0)); -} - -void AffichageBasique() { - ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); - RemplirRectangle(0, 0, 1175, 775); -} - -void AfficherScore() { - char scoreText[20]; // Correction de la taille du tableau - snprintf(scoreText, 20, "Score: %d", score); - ChoisirCouleurDessin(CouleurParComposante(0, 0, 0)); - RemplirRectangle(20, 820, 150, 40); - ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); - EcrireTexte(20, 850, scoreText, 2); -} - -int PauseJeu() { - while (1) { - if (ToucheEnAttente()) { - int touche = Touche(); - if (touche == XK_space) { - return 1; // La barre d'espace a été pressée, reprendre le jeu - } - } - Attendre(100); - } -} - -void LibererMemoire() { - free(serpent.corps); - free(pommes.positions); -} - -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); -} - -void AfficherSerpent() { - couleur couleurSerpent = CouleurParComposante(255, 255, 0); - ChoisirCouleurDessin(couleurSerpent); - - for (int i = 0; i < serpent.longueur; i++) { - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); - } -} - -void GenererPommes() { - couleur couleurPommes = CouleurParComposante(255, 0, 0); - pommes.positions = malloc(sizeof(Position) * pommes.nombre); - - for (int i = 0; i < pommes.nombre; i++) { - pommes.positions[i].x = rand() % LARGEUR; - pommes.positions[i].y = rand() % HAUTEUR; - ChoisirCouleurDessin(couleurPommes); - RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); - } -} - -void GenererNouvellePomme() { - couleur couleurPommes = CouleurParComposante(255, 0, 0); - int i = rand() % pommes.nombre; // Utilisation d'une position aléatoire - pommes.positions[i].x = rand() % LARGEUR; - pommes.positions[i].y = rand() % HAUTEUR; - ChoisirCouleurDessin(couleurPommes); - RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); -} - -int CollisionAvecPomme() { - for (int i = 0; i < pommes.nombre; i++) { - /* Vérifier si la tête du serpent est à l'intérieur de la zone de la pomme*/ - if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE && - serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE && - serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE && - serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) { - GenererNouvellePomme(); // Générer une nouvelle position pour la pomme mangée - score= score +5; // Augmenter le score - AfficherScore(); // Mettre à jour l'affichage du score - return 1; - } - } - return 0; -} - -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) { - perdu = -1; // Le serpent a perdu - return 1; - } - } - return 0; -} - -int CollisionAvecBordures() { - if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE || - serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) { - perdu = -1; // Le serpent a perdu - return 1; - } - return 0; -} - -void DeplacerSerpent(int* direction) { - couleur couleurFond = CouleurParComposante(0, 0, 0); - couleur couleurSerpent = CouleurParComposante(255, 255, 0); - couleur couleurTerrain = CouleurParComposante(111, 255, 94); - - for (int i = 0; i < serpent.longueur; i++) { - ChoisirCouleurDessin(couleurTerrain); - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); - } - - for (int i = serpent.longueur - 1; i > 0; i--) { - serpent.corps[i] = serpent.corps[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; - } - } - - 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; - } - - for (int i = 0; i < serpent.longueur; i++) { - ChoisirCouleurDessin(couleurSerpent); - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); - } - - Attendre(100); -} - -int GestionCollision(int perdu) { - int loose = perdu; - if (CollisionAvecPomme()) { - serpent.longueur = serpent.longueur +2; - serpent.corps = realloc(serpent.corps, sizeof(Position) * serpent.longueur); - loose = 1; - } - if (CollisionAvecSerpent() || CollisionAvecBordures()) { - loose = -1; /* Le serpent a perdu*/ - } - printf("%d \n", loose); - return loose; -} - -int main() { - int direction = 1; - unsigned long suivant = Microsecondes() + CYCLE; - int temps[2] = {0, 0}, seconde_actuel, old_seconde; - int jeuEnPause = 0; - int perdu = 0; - - InitialiserJeu(); - Graphique(); - EffacerEcran(CouleurParComposante(0, 0, 0)); - AffichageBasique(); - GenererPommes(); - AfficherSerpent(); - AfficherScore(); - - while (perdu != -1) { - if (!jeuEnPause) { - 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]++; - } - AfficheTemps(temps[0], temps[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; - case XK_space: - jeuEnPause = 1; - break; - } - } - DeplacerSerpent(&direction); - perdu = GestionCollision(perdu); - if (perdu == 1) { - GenererNouvellePomme(); - perdu = 0; - } - } else { - // Le jeu est en pause - if (ToucheEnAttente()) { - int touche = Touche(); - if (touche == XK_space) { - jeuEnPause = 0; - } - } - } - } - - FermerGraphique(); - LibererMemoire(); - return EXIT_SUCCESS; -} diff --git a/snake.c b/snake.c deleted file mode 100644 index 29484b9..0000000 --- a/snake.c +++ /dev/null @@ -1,298 +0,0 @@ -#include -#include -#include -#include -#include - -#define HAUTEUR 40 -#define LARGEUR 60 -#define TAILLE_CASE 19 -#define NOMBRE_POMMES 5 -#define CYCLE 100000L - -typedef struct { - int x; - int y; -} Position; - -typedef struct { - Position* corps; - int longueur; -} Serpent; - -typedef struct { - Position* positions; - int nombre; -} Pommes; - -Serpent serpent; -Pommes pommes; -int score = 0; // Ajout de la variable score - -int perdu = 0; // Variable pour indiquer si le serpent a perdu - -void Attendre(unsigned int millisecondes) { - usleep(millisecondes * 1000); -} - -void InitialiserJeu() { - serpent.longueur = 10; - serpent.corps = malloc(sizeof(Position) * serpent.longueur); - pommes.nombre = NOMBRE_POMMES; - - srand(time(NULL)); - - serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE; - serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE; - perdu = 0; // Initialisation de la variable perdu -} - -void Graphique() { - InitialiserGraphique(); - CreerFenetre(1, 1, 1240, 940); - EcrireTexte(500, 400, "Le jeu va commencer !", 2); - Attendre(1000); - EffacerEcran(CouleurParComposante(0, 0, 0)); -} - -void AffichageBasique() { - ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); - RemplirRectangle(0, 0, 1175, 775); -} - -void AfficherScore() { - char scoreText[20]; // Correction de la taille du tableau - snprintf(scoreText, 20, "Score: %d", score); - ChoisirCouleurDessin(CouleurParComposante(0, 0, 0)); - RemplirRectangle(20, 820, 150, 40); - ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); - EcrireTexte(20, 850, scoreText, 2); -} - -int PauseJeu() { - while (1) { - if (ToucheEnAttente()) { - int touche = Touche(); - if (touche == XK_space) { - return 1; // La barre d'espace a été pressée, reprendre le jeu - } - } - Attendre(100); - } -} - -void LibererMemoire() { - free(serpent.corps); - free(pommes.positions); -} - -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); -} - -void AfficherSerpent() { - couleur couleurSerpent = CouleurParComposante(255, 255, 0); - ChoisirCouleurDessin(couleurSerpent); - - for (int i = 0; i < serpent.longueur; i++) { - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); - } -} - -void GenererPommes() { - couleur couleurPommes = CouleurParComposante(255, 0, 0); - pommes.positions = malloc(sizeof(Position) * pommes.nombre); - - for (int i = 0; i < pommes.nombre; i++) { - pommes.positions[i].x = rand() % LARGEUR; - pommes.positions[i].y = rand() % HAUTEUR; - ChoisirCouleurDessin(couleurPommes); - RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); - } -} - -void GenererNouvellePomme() { - couleur couleurPommes = CouleurParComposante(255, 0, 0); - int i = rand() % pommes.nombre; // Utilisation d'une position aléatoire - pommes.positions[i].x = rand() % LARGEUR; - pommes.positions[i].y = rand() % HAUTEUR; - ChoisirCouleurDessin(couleurPommes); - RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); -} - -int CollisionAvecPomme() { - for (int i = 0; i < pommes.nombre; i++) { - /* Vérifier si la tête du serpent est à l'intérieur de la zone de la pomme*/ - if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE && - serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE && - serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE && - serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) { - GenererNouvellePomme(); // Générer une nouvelle position pour la pomme mangée - score= score +5; // Augmenter le score - AfficherScore(); // Mettre à jour l'affichage du score - return 1; - } - } - return 0; -} - -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) { - perdu = -1; // Le serpent a perdu - return 1; - } - } - return 0; -} - -int CollisionAvecBordures() { - if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE || - serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) { - perdu = -1; // Le serpent a perdu - return 1; - } - return 0; -} - -void DeplacerSerpent(int* direction) { - couleur couleurFond = CouleurParComposante(0, 0, 0); - couleur couleurSerpent = CouleurParComposante(255, 255, 0); - couleur couleurTerrain = CouleurParComposante(111, 255, 94); - - for (int i = 0; i < serpent.longueur; i++) { - ChoisirCouleurDessin(couleurTerrain); - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); - } - - for (int i = serpent.longueur - 1; i > 0; i--) { - serpent.corps[i] = serpent.corps[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; - } - } - - 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; - } - - for (int i = 0; i < serpent.longueur; i++) { - ChoisirCouleurDessin(couleurSerpent); - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); - } - - Attendre(100); -} - -int GestionCollision(int perdu) { - int loose = perdu; - if (CollisionAvecPomme()) { - serpent.longueur = serpent.longueur +2; - serpent.corps = realloc(serpent.corps, sizeof(Position) * serpent.longueur); - loose = 1; - } - if (CollisionAvecSerpent() || CollisionAvecBordures()) { - loose = -1; /* Le serpent a perdu*/ - } - printf("%d \n", loose); - return loose; -} - -int main() { - int direction = 1; - unsigned long suivant = Microsecondes() + CYCLE; - int temps[2] = {0, 0}, seconde_actuel, old_seconde; - int jeuEnPause = 0; - int perdu = 0; - - InitialiserJeu(); - Graphique(); - EffacerEcran(CouleurParComposante(0, 0, 0)); - AffichageBasique(); - GenererPommes(); - AfficherSerpent(); - AfficherScore(); - - while (perdu != -1) { - if (!jeuEnPause) { - 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]++; - } - AfficheTemps(temps[0], temps[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; - case XK_space: - jeuEnPause = 1; - break; - } - } - DeplacerSerpent(&direction); - perdu = GestionCollision(perdu); - if (perdu == 1) { - GenererNouvellePomme(); - perdu = 0; - } - } else { - // Le jeu est en pause - if (ToucheEnAttente()) { - int touche = Touche(); - if (touche == XK_space) { - jeuEnPause = 0; - } - } - } - } - - FermerGraphique(); - LibererMemoire(); - return EXIT_SUCCESS; -} From 0b187e7d15818935124881780c1cffb163c21773 Mon Sep 17 00:00:00 2001 From: rognant Date: Mon, 11 Dec 2023 14:36:30 +0100 Subject: [PATCH 4/9] m --- #jeu.c# | 191 -------------------------------------------------------- idée.c | 158 ---------------------------------------------- jeu.c | 191 -------------------------------------------------------- 3 files changed, 540 deletions(-) delete mode 100644 #jeu.c# delete mode 100644 idée.c delete mode 100644 jeu.c diff --git a/#jeu.c# b/#jeu.c# deleted file mode 100644 index f96c3c4..0000000 --- a/#jeu.c# +++ /dev/null @@ -1,191 +0,0 @@ -#include -#include -#include -#include - -#define HAUTEUR 40 -#define LARGEUR 60 -#define CYCLE 100000L -#define TAILLE_CASE 20 -#define SCORE_TO_WIN 50 - -/* 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, 1175, 775); -} - -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) { - 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, int *aMangerPomme) { - int i; - /* Vérifie la collision avec la pomme */ - 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; - *aMangerPomme = 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 = RIGHT; // Ajout de la direction initiale - int aMangerPomme = 0; - 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, &aMangerPomme); - serpent(snake, taille); - - - } - } - /* Génération de nouvelles pommes si le serpent en a mangé une */ - if (aMangerPomme) { - aMangerPomme = 0; // Réinitialise la variable après avoir généré les pommes - genererPommes(pommes); - perdu = 0; /* enlever ça pour faire des obstacle*/ - } - - if (perdu == -1) { - printf("Vous avez perdu ! Collision avec la paroi.\n"); - FermerGraphique(); - *score =0; - } - - - - return EXIT_SUCCESS; -} diff --git a/idée.c b/idée.c deleted file mode 100644 index 3307497..0000000 --- a/idée.c +++ /dev/null @@ -1,158 +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[100]; // 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, enum direction dir) { - // 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 - switch (dir) { - case UP: - snake->queue[0].y--; - break; - case DOWN: - snake->queue[0].y++; - break; - case LEFT: - snake->queue[0].x--; - break; - case RIGHT: - snake->queue[0].x++; - break; - } -} - -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.queue[0].x = NOMBRE_CASES_X / 2; - snake.queue[0].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; - - enum direction direction = RIGHT; // Direction initiale - - while (1) { - EffacerEcran(0); - - deplacerSnake(&snake, direction); - 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; - } - - if (ToucheEnAttente()) { - int touche = Touche(); - if (touche == 65 && direction != DOWN) { // 65 correspond à la touche '↑' - direction = UP; - } else if (touche == 66 && direction != UP) { // 66 correspond à la touche '↓' - direction = DOWN; - } else if (touche == 68 && direction != RIGHT) { // 68 correspond à la touche '←' - direction = LEFT; - } else if (touche == 67 && direction != LEFT) { // 67 correspond à la touche '→' - direction = RIGHT; - } - } - } -} - -int main(void) { - Snake snake; - Fruit fruit; - enum direction{RIGHT,UP,LEFT,DOWN}; - Position positionCase; - positionCase.x = 5; - positionCase.y = 5; - couleur couleurCase = CouleurParComposante(255, 255, 255); - initialiserGraphique(); - dessinerCase(positionCase, couleurCase); - afficherSnake(&Snake); - afficherFruit(&Fruit); - deplacerSnake(&Snake, direction); - jeuSnake(); - - - return EXIT_SUCCESS; -} diff --git a/jeu.c b/jeu.c deleted file mode 100644 index 0c1db52..0000000 --- a/jeu.c +++ /dev/null @@ -1,191 +0,0 @@ -#include -#include -#include -#include - -#define HAUTEUR 40 -#define LARGEUR 60 -#define CYCLE 100000L -#define TAILLE_CASE 20 -#define SCORE_TO_WIN 50 - -/* 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, 1175, 775); -} - -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) { - 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, int *aMangerPomme) { - int i; - /* Vérifie la collision avec la pomme */ - 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; - *aMangerPomme = 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 = RIGHT; // Ajout de la direction initiale - int aMangerPomme = 0; - 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, &aMangerPomme); - serpent(snake, taille); - - - } - } - /* Génération de nouvelles pommes si le serpent en a mangé une */ - if (aMangerPomme) { - aMangerPomme = 0; // Réinitialise la variable après avoir généré les pommes - genererPommes(pommes); - perdu = 0; /* enlever ça pour faire des obstacle*/ - } - - if (perdu == -1) { - printf("Vous avez perdu ! Collision avec la paroi.\n"); - FermerGraphique(); - *score =0; - } - - - - return EXIT_SUCCESS; -} From c994f533cd038e5f45fbfe8a908490ca85c72718 Mon Sep 17 00:00:00 2001 From: rognant Date: Mon, 11 Dec 2023 14:37:54 +0100 Subject: [PATCH 5/9] t --- snake.c | 140 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 140 insertions(+) create mode 100644 snake.c diff --git a/snake.c b/snake.c new file mode 100644 index 0000000..c3681b2 --- /dev/null +++ b/snake.c @@ -0,0 +1,140 @@ +#include +#include +#include +#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; + +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)); +} + +void AffichageBasique() { + ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); + RemplirRectangle(10, 10, TAILLE_CASE * LARGEUR, TAILLE_CASE * LARGEUR); +} + +/* 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); + } +} + +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); + } +} + +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); +} + + +int main() { + 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 */ + serpent[0].x = LARGEUR / 2 * TAILLE_CASE; + serpent[0].y = HAUTEUR / 2 * TAILLE_CASE; + + + Graphique(); + EffacerEcran(c); + AffichageBasique(); + genererPommes(pommes); + afficherSerpent(serpent, longueurSerpent); + + while (perdu!=-1) { + deplacerSerpent(longueurSerpent, serpent, &direction); + } + + Touche(); + FermerGraphique(); + return EXIT_SUCCESS; +} From 04f0411ed528e6e6f079cec5f625c2a5f0afcf98 Mon Sep 17 00:00:00 2001 From: rognant Date: Mon, 11 Dec 2023 14:40:56 +0100 Subject: [PATCH 6/9] t --- snake.c | 140 -------------------------------------------------------- 1 file changed, 140 deletions(-) delete mode 100644 snake.c diff --git a/snake.c b/snake.c deleted file mode 100644 index c3681b2..0000000 --- a/snake.c +++ /dev/null @@ -1,140 +0,0 @@ -#include -#include -#include -#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; - -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)); -} - -void AffichageBasique() { - ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); - RemplirRectangle(10, 10, TAILLE_CASE * LARGEUR, TAILLE_CASE * LARGEUR); -} - -/* 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); - } -} - -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); - } -} - -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); -} - - -int main() { - 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 */ - serpent[0].x = LARGEUR / 2 * TAILLE_CASE; - serpent[0].y = HAUTEUR / 2 * TAILLE_CASE; - - - Graphique(); - EffacerEcran(c); - AffichageBasique(); - genererPommes(pommes); - afficherSerpent(serpent, longueurSerpent); - - while (perdu!=-1) { - deplacerSerpent(longueurSerpent, serpent, &direction); - } - - Touche(); - FermerGraphique(); - return EXIT_SUCCESS; -} From 3548dd3f0fb3d4304646bad6643740089e5ad1e8 Mon Sep 17 00:00:00 2001 From: rognant Date: Mon, 11 Dec 2023 14:45:42 +0100 Subject: [PATCH 7/9] m --- Makefile | 14 +++ serpent.c | 298 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 312 insertions(+) create mode 100644 Makefile create mode 100644 serpent.c diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..52c764f --- /dev/null +++ b/Makefile @@ -0,0 +1,14 @@ +CC = gcc +CFLAGS = -Wall -Wextra -I. +LIBS = -lgraph + +all: serpent + +serpent: main.o serpent.o + $(CC) $(CFLAGS) $^ -o $@ $(LIBS) + +%.o: %.c + $(CC) $(CFLAGS) -c $< -o $@ + +clean: + rm -f *.o serpent diff --git a/serpent.c b/serpent.c new file mode 100644 index 0000000..29484b9 --- /dev/null +++ b/serpent.c @@ -0,0 +1,298 @@ +#include +#include +#include +#include +#include + +#define HAUTEUR 40 +#define LARGEUR 60 +#define TAILLE_CASE 19 +#define NOMBRE_POMMES 5 +#define CYCLE 100000L + +typedef struct { + int x; + int y; +} Position; + +typedef struct { + Position* corps; + int longueur; +} Serpent; + +typedef struct { + Position* positions; + int nombre; +} Pommes; + +Serpent serpent; +Pommes pommes; +int score = 0; // Ajout de la variable score + +int perdu = 0; // Variable pour indiquer si le serpent a perdu + +void Attendre(unsigned int millisecondes) { + usleep(millisecondes * 1000); +} + +void InitialiserJeu() { + serpent.longueur = 10; + serpent.corps = malloc(sizeof(Position) * serpent.longueur); + pommes.nombre = NOMBRE_POMMES; + + srand(time(NULL)); + + serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE; + serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE; + perdu = 0; // Initialisation de la variable perdu +} + +void Graphique() { + InitialiserGraphique(); + CreerFenetre(1, 1, 1240, 940); + EcrireTexte(500, 400, "Le jeu va commencer !", 2); + Attendre(1000); + EffacerEcran(CouleurParComposante(0, 0, 0)); +} + +void AffichageBasique() { + ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); + RemplirRectangle(0, 0, 1175, 775); +} + +void AfficherScore() { + char scoreText[20]; // Correction de la taille du tableau + snprintf(scoreText, 20, "Score: %d", score); + ChoisirCouleurDessin(CouleurParComposante(0, 0, 0)); + RemplirRectangle(20, 820, 150, 40); + ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); + EcrireTexte(20, 850, scoreText, 2); +} + +int PauseJeu() { + while (1) { + if (ToucheEnAttente()) { + int touche = Touche(); + if (touche == XK_space) { + return 1; // La barre d'espace a été pressée, reprendre le jeu + } + } + Attendre(100); + } +} + +void LibererMemoire() { + free(serpent.corps); + free(pommes.positions); +} + +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); +} + +void AfficherSerpent() { + couleur couleurSerpent = CouleurParComposante(255, 255, 0); + ChoisirCouleurDessin(couleurSerpent); + + for (int i = 0; i < serpent.longueur; i++) { + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); + } +} + +void GenererPommes() { + couleur couleurPommes = CouleurParComposante(255, 0, 0); + pommes.positions = malloc(sizeof(Position) * pommes.nombre); + + for (int i = 0; i < pommes.nombre; i++) { + pommes.positions[i].x = rand() % LARGEUR; + pommes.positions[i].y = rand() % HAUTEUR; + ChoisirCouleurDessin(couleurPommes); + RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); + } +} + +void GenererNouvellePomme() { + couleur couleurPommes = CouleurParComposante(255, 0, 0); + int i = rand() % pommes.nombre; // Utilisation d'une position aléatoire + pommes.positions[i].x = rand() % LARGEUR; + pommes.positions[i].y = rand() % HAUTEUR; + ChoisirCouleurDessin(couleurPommes); + RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); +} + +int CollisionAvecPomme() { + for (int i = 0; i < pommes.nombre; i++) { + /* Vérifier si la tête du serpent est à l'intérieur de la zone de la pomme*/ + if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE && + serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE && + serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE && + serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) { + GenererNouvellePomme(); // Générer une nouvelle position pour la pomme mangée + score= score +5; // Augmenter le score + AfficherScore(); // Mettre à jour l'affichage du score + return 1; + } + } + return 0; +} + +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) { + perdu = -1; // Le serpent a perdu + return 1; + } + } + return 0; +} + +int CollisionAvecBordures() { + if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE || + serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) { + perdu = -1; // Le serpent a perdu + return 1; + } + return 0; +} + +void DeplacerSerpent(int* direction) { + couleur couleurFond = CouleurParComposante(0, 0, 0); + couleur couleurSerpent = CouleurParComposante(255, 255, 0); + couleur couleurTerrain = CouleurParComposante(111, 255, 94); + + for (int i = 0; i < serpent.longueur; i++) { + ChoisirCouleurDessin(couleurTerrain); + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); + } + + for (int i = serpent.longueur - 1; i > 0; i--) { + serpent.corps[i] = serpent.corps[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; + } + } + + 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; + } + + for (int i = 0; i < serpent.longueur; i++) { + ChoisirCouleurDessin(couleurSerpent); + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); + } + + Attendre(100); +} + +int GestionCollision(int perdu) { + int loose = perdu; + if (CollisionAvecPomme()) { + serpent.longueur = serpent.longueur +2; + serpent.corps = realloc(serpent.corps, sizeof(Position) * serpent.longueur); + loose = 1; + } + if (CollisionAvecSerpent() || CollisionAvecBordures()) { + loose = -1; /* Le serpent a perdu*/ + } + printf("%d \n", loose); + return loose; +} + +int main() { + int direction = 1; + unsigned long suivant = Microsecondes() + CYCLE; + int temps[2] = {0, 0}, seconde_actuel, old_seconde; + int jeuEnPause = 0; + int perdu = 0; + + InitialiserJeu(); + Graphique(); + EffacerEcran(CouleurParComposante(0, 0, 0)); + AffichageBasique(); + GenererPommes(); + AfficherSerpent(); + AfficherScore(); + + while (perdu != -1) { + if (!jeuEnPause) { + 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]++; + } + AfficheTemps(temps[0], temps[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; + case XK_space: + jeuEnPause = 1; + break; + } + } + DeplacerSerpent(&direction); + perdu = GestionCollision(perdu); + if (perdu == 1) { + GenererNouvellePomme(); + perdu = 0; + } + } else { + // Le jeu est en pause + if (ToucheEnAttente()) { + int touche = Touche(); + if (touche == XK_space) { + jeuEnPause = 0; + } + } + } + } + + FermerGraphique(); + LibererMemoire(); + return EXIT_SUCCESS; +} From c69ec713e06f3613ef1d1c6f403d3bf70e439aa8 Mon Sep 17 00:00:00 2001 From: rognant Date: Mon, 11 Dec 2023 16:09:56 +0100 Subject: [PATCH 8/9] t --- #serpent.c# | 303 ++++++++++++++++++++++++++++++++++++++++ .#serpent.c | 1 + serpent.c | 387 ++++++++++++++++++++++++++-------------------------- 3 files changed, 500 insertions(+), 191 deletions(-) create mode 100644 #serpent.c# create mode 120000 .#serpent.c diff --git a/#serpent.c# b/#serpent.c# new file mode 100644 index 0000000..236c563 --- /dev/null +++ b/#serpent.c# @@ -0,0 +1,303 @@ +#include +#include +#include +#include +#include + +#define HAUTEUR 40 +#define LARGEUR 60 +#define TAILLE_CASE 19 +#define NOMBRE_POMMES 5 +#define CYCLE 100000L + +typedef struct { + int x; + int y; +} Position; + +typedef struct { + Position* corps; + int longueur; +} Serpent; + +typedef struct { + Position* positions; + int nombre; +} Pommes; + +Serpent serpent; +Pommes pommes; + +int score = 0; +int perdu = 0; + +void Attendre(unsigned int millisecondes) { + usleep(millisecondes * 1000); +} + +void InitialiserJeu() { + serpent.longueur = 10; + serpent.corps = malloc(sizeof(Position) * serpent.longueur); + pommes.nombre = NOMBRE_POMMES; + + srand(time(NULL)); + + serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE; + serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE; + perdu = 0; /* Initialisation de la variable perdu*/ +} + +void Graphique() { + InitialiserGraphique(); + CreerFenetre(1, 1, 1240, 940); + EcrireTexte(500, 400, "Le jeu va commencer !", 2); + Attendre(1000); + EffacerEcran(CouleurParComposante(0, 0, 0)); +} + +void AffichageBasique() { + ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); + RemplirRectangle(0, 0, 1140, 760); +} + +void AfficherScore() { + char scoreText[20]; /* Correction de la taille du tableau*/ + snprintf(scoreText, 20, "Score: %d", score); + ChoisirCouleurDessin(CouleurParComposante(0, 0, 0)); + RemplirRectangle(20, 820, 150, 40); + ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); + EcrireTexte(20, 850, scoreText, 2); +} + +int PauseJeu() { + while (1) { + if (ToucheEnAttente()) { + int touche = Touche(); + if (touche == XK_space) { + return 1; /* La barre d'espace a été pressée, reprendre le jeu*/ + } + } + Attendre(100); + } +} + +void LibererMemoire() { + free(serpent.corps); + free(pommes.positions); +} + +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); +} + +void AfficherSerpent() { + couleur couleurSerpent = CouleurParComposante(255, 255, 0); + ChoisirCouleurDessin(couleurSerpent); + + for (int i = 0; i < serpent.longueur; i++) { + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); + } +} + +void GenererPommes() { + couleur couleurPommes = CouleurParComposante(255, 0, 0); + pommes.positions = malloc(sizeof(Position) * pommes.nombre); + + for (int i = 0; i < pommes.nombre; i++) { + pommes.positions[i].x = rand() % LARGEUR; + pommes.positions[i].y = rand() % HAUTEUR; + ChoisirCouleurDessin(couleurPommes); + RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); + } +} + +void GenererNouvellePomme() { + couleur couleurPommes = CouleurParComposante(255, 0, 0); + int i = rand() % pommes.nombre; /* Utilisation d'une position aléatoire*/ + pommes.positions[i].x = rand() % LARGEUR; + pommes.positions[i].y = rand() % HAUTEUR; + ChoisirCouleurDessin(couleurPommes); + RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); +} + +int CollisionAvecPomme() { + for (int i = 0; i < pommes.nombre; i++) { + /* Vérifier si la tête du serpent est à l'intérieur de la zone de la pomme*/ + if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE && + serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE && + serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE && + serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) { + GenererNouvellePomme(); /* Générer une nouvelle position pour la pomme mangée*/ + score= score +5; /* Augmenter le score*/ + AfficherScore(); /* Mettre à jour l'affichage du score*/ + return 1; + } + } + return 0; +} + +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) { + perdu = -1; // Le serpent a perdu + return 1; + } + } + return 0; +} + +int CollisionAvecBordures() { + if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE || + serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) { + perdu = -1; // Le serpent a perdu + return 1; + } + return 0; +} + +void DeplacerSerpent(int* direction) { + couleur couleurFond = CouleurParComposante(0, 0, 0); + couleur couleurSerpent = CouleurParComposante(255, 255, 0); + couleur couleurTerrain = CouleurParComposante(111, 255, 94); + + for (int i = 0; i < serpent.longueur; i++) { + ChoisirCouleurDessin(couleurTerrain); + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); + } + + for (int i = serpent.longueur - 1; i > 0; i--) { + serpent.corps[i] = serpent.corps[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; + } + } + + 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; + } + + for (int i = 0; i < serpent.longueur; i++) { + ChoisirCouleurDessin(couleurSerpent); + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); + } + + Attendre(100); +} + +int GestionCollision(int perdu) { + int loose = perdu; + if (CollisionAvecPomme()) { + serpent.longueur = serpent.longueur +2; + serpent.corps = realloc(serpent.corps, sizeof(Position) * serpent.longueur); + loose = 1; + } + if (CollisionAvecSerpent() || CollisionAvecBordures()) { + loose = -1; /* Le serpent a perdu*/ + } + /*printf("%d \n", loose);*/ + return loose; +} + +int main() { + int direction = 1; + unsigned long suivant = Microsecondes() + CYCLE; + int temps[2] = {0, 0}, seconde_actuel, old_seconde; + int jeuEnPause = 0; + int perdu = 0; + + InitialiserJeu(); + Graphique(); + EffacerEcran(CouleurParComposante(0, 0, 0)); + AffichageBasique(); + GenererPommes(); + AfficherSerpent(); + AfficherScore(); + + while (perdu != -1) { + if (!jeuEnPause) { + 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]++; + } + AfficheTemps(temps[0], temps[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; + case XK_space: + jeuEnPause = 1; + break; + case XK_Escape: + return EXIT_FAILURE; + } + } + DeplacerSerpent(&direction); + perdu = GestionCollision(perdu); + if (perdu == 1) { + GenererNouvellePomme(); + perdu = 0; + } + } else { + /* Le jeu est en pause*/ + if (ToucheEnAttente()) { + int touche = Touche(); + if (touche == XK_space) { + if(touche == XK_Escape){ + return EXIT_FAILURE; + } + jeuEnPause = 0; + } + } + } + } + + FermerGraphique(); + LibererMemoire(); + return EXIT_SUCCESS; +} diff --git a/.#serpent.c b/.#serpent.c new file mode 120000 index 0000000..4a26999 --- /dev/null +++ b/.#serpent.c @@ -0,0 +1 @@ +rognant@salle235-14.17429:1702034892 \ No newline at end of file diff --git a/serpent.c b/serpent.c index 29484b9..18c0b12 100644 --- a/serpent.c +++ b/serpent.c @@ -27,187 +27,187 @@ typedef struct { Serpent serpent; Pommes pommes; -int score = 0; // Ajout de la variable score -int perdu = 0; // Variable pour indiquer si le serpent a perdu +int score = 0; +int perdu = 0; void Attendre(unsigned int millisecondes) { - usleep(millisecondes * 1000); + usleep(millisecondes * 1000); } void InitialiserJeu() { - serpent.longueur = 10; - serpent.corps = malloc(sizeof(Position) * serpent.longueur); - pommes.nombre = NOMBRE_POMMES; + serpent.longueur = 10; + serpent.corps = malloc(sizeof(Position) * serpent.longueur); + pommes.nombre = NOMBRE_POMMES; - srand(time(NULL)); + srand(time(NULL)); - serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE; - serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE; - perdu = 0; // Initialisation de la variable perdu + serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE; + serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE; + perdu = 0; /* Initialisation de la variable perdu*/ } void Graphique() { - InitialiserGraphique(); - CreerFenetre(1, 1, 1240, 940); - EcrireTexte(500, 400, "Le jeu va commencer !", 2); - Attendre(1000); - EffacerEcran(CouleurParComposante(0, 0, 0)); + InitialiserGraphique(); + CreerFenetre(1, 1, 1240, 940); + EcrireTexte(500, 400, "Le jeu va commencer !", 2); + Attendre(1000); + EffacerEcran(CouleurParComposante(0, 0, 0)); } void AffichageBasique() { - ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); - RemplirRectangle(0, 0, 1175, 775); + ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); + RemplirRectangle(0, 0, 1140, 760); } void AfficherScore() { - char scoreText[20]; // Correction de la taille du tableau - snprintf(scoreText, 20, "Score: %d", score); - ChoisirCouleurDessin(CouleurParComposante(0, 0, 0)); - RemplirRectangle(20, 820, 150, 40); - ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); - EcrireTexte(20, 850, scoreText, 2); + char scoreText[20]; /* Correction de la taille du tableau*/ + snprintf(scoreText, 20, "Score: %d", score); + ChoisirCouleurDessin(CouleurParComposante(0, 0, 0)); + RemplirRectangle(20, 820, 150, 40); + ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); + EcrireTexte(20, 850, scoreText, 2); } int PauseJeu() { - while (1) { - if (ToucheEnAttente()) { - int touche = Touche(); - if (touche == XK_space) { - return 1; // La barre d'espace a été pressée, reprendre le jeu - } - } - Attendre(100); + while (1) { + if (ToucheEnAttente()) { + int touche = Touche(); + if (touche == XK_space) { + return 1; /* La barre d'espace a été pressée, reprendre le jeu*/ + } } + Attendre(100); + } } void LibererMemoire() { - free(serpent.corps); - free(pommes.positions); + free(serpent.corps); + free(pommes.positions); } 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); + 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); } void AfficherSerpent() { - couleur couleurSerpent = CouleurParComposante(255, 255, 0); - ChoisirCouleurDessin(couleurSerpent); + couleur couleurSerpent = CouleurParComposante(255, 255, 0); + ChoisirCouleurDessin(couleurSerpent); - for (int i = 0; i < serpent.longueur; i++) { - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, 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); + } } void GenererPommes() { - couleur couleurPommes = CouleurParComposante(255, 0, 0); - pommes.positions = malloc(sizeof(Position) * pommes.nombre); - - for (int i = 0; i < pommes.nombre; i++) { - pommes.positions[i].x = rand() % LARGEUR; - pommes.positions[i].y = rand() % HAUTEUR; - ChoisirCouleurDessin(couleurPommes); - RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); - } -} - -void GenererNouvellePomme() { - couleur couleurPommes = CouleurParComposante(255, 0, 0); - int i = rand() % pommes.nombre; // Utilisation d'une position aléatoire + couleur couleurPommes = CouleurParComposante(255, 0, 0); + pommes.positions = malloc(sizeof(Position) * pommes.nombre); + + for (int i = 0; i < pommes.nombre; i++) { pommes.positions[i].x = rand() % LARGEUR; pommes.positions[i].y = rand() % HAUTEUR; ChoisirCouleurDessin(couleurPommes); RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); + } +} + +void GenererNouvellePomme() { + couleur couleurPommes = CouleurParComposante(255, 0, 0); + int i = rand() % pommes.nombre; /* Utilisation d'une position aléatoire*/ + pommes.positions[i].x = rand() % LARGEUR; + pommes.positions[i].y = rand() % HAUTEUR; + ChoisirCouleurDessin(couleurPommes); + RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); } int CollisionAvecPomme() { - for (int i = 0; i < pommes.nombre; i++) { - /* Vérifier si la tête du serpent est à l'intérieur de la zone de la pomme*/ - if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE && - serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE && - serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE && - serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) { - GenererNouvellePomme(); // Générer une nouvelle position pour la pomme mangée - score= score +5; // Augmenter le score - AfficherScore(); // Mettre à jour l'affichage du score - return 1; - } + for (int i = 0; i < pommes.nombre; i++) { + /* Vérifier si la tête du serpent est à l'intérieur de la zone de la pomme*/ + if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE && + serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE && + serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE && + serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) { + GenererNouvellePomme(); /* Générer une nouvelle position pour la pomme mangée*/ + score= score +5; /* Augmenter le score*/ + AfficherScore(); /* Mettre à jour l'affichage du score*/ + return 1; } - return 0; + } + return 0; } 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) { - perdu = -1; // Le serpent a perdu - return 1; - } + 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) { + perdu = -1; // Le serpent a perdu + return 1; } - return 0; + } + return 0; } int CollisionAvecBordures() { - if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE || - serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) { - perdu = -1; // Le serpent a perdu - return 1; - } - return 0; + if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE || + serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) { + perdu = -1; // Le serpent a perdu + return 1; + } + return 0; } void DeplacerSerpent(int* direction) { - couleur couleurFond = CouleurParComposante(0, 0, 0); - couleur couleurSerpent = CouleurParComposante(255, 255, 0); - couleur couleurTerrain = CouleurParComposante(111, 255, 94); + couleur couleurFond = CouleurParComposante(0, 0, 0); + couleur couleurSerpent = CouleurParComposante(255, 255, 0); + couleur couleurTerrain = CouleurParComposante(111, 255, 94); + + for (int i = 0; i < serpent.longueur; i++) { + ChoisirCouleurDessin(couleurTerrain); + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); + } + + for (int i = serpent.longueur - 1; i > 0; i--) { + serpent.corps[i] = serpent.corps[i - 1]; + } - for (int i = 0; i < serpent.longueur; i++) { - ChoisirCouleurDessin(couleurTerrain); - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); + 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; } + } - for (int i = serpent.longueur - 1; i > 0; i--) { - serpent.corps[i] = serpent.corps[i - 1]; - } + 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; + } - 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; - } - } + for (int i = 0; i < serpent.longueur; i++) { + ChoisirCouleurDessin(couleurSerpent); + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); + } - 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; - } - - for (int i = 0; i < serpent.longueur; i++) { - ChoisirCouleurDessin(couleurSerpent); - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); - } - - Attendre(100); + Attendre(100); } int GestionCollision(int perdu) { @@ -220,79 +220,84 @@ int GestionCollision(int perdu) { if (CollisionAvecSerpent() || CollisionAvecBordures()) { loose = -1; /* Le serpent a perdu*/ } - printf("%d \n", loose); + /*printf("%d \n", loose);*/ return loose; } int main() { - int direction = 1; - unsigned long suivant = Microsecondes() + CYCLE; - int temps[2] = {0, 0}, seconde_actuel, old_seconde; - int jeuEnPause = 0; - int perdu = 0; + int direction = 1; + unsigned long suivant = Microsecondes() + CYCLE; + int temps[2] = {0, 0}, seconde_actuel, old_seconde; + int jeuEnPause = 0; + int perdu = 0; - InitialiserJeu(); - Graphique(); - EffacerEcran(CouleurParComposante(0, 0, 0)); - AffichageBasique(); - GenererPommes(); - AfficherSerpent(); - AfficherScore(); + InitialiserJeu(); + Graphique(); + EffacerEcran(CouleurParComposante(0, 0, 0)); + AffichageBasique(); + GenererPommes(); + AfficherSerpent(); + AfficherScore(); - while (perdu != -1) { - if (!jeuEnPause) { - 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]++; - } - AfficheTemps(temps[0], temps[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; - case XK_space: - jeuEnPause = 1; - break; - } - } - DeplacerSerpent(&direction); - perdu = GestionCollision(perdu); - if (perdu == 1) { - GenererNouvellePomme(); - perdu = 0; - } - } else { - // Le jeu est en pause - if (ToucheEnAttente()) { - int touche = Touche(); - if (touche == XK_space) { - jeuEnPause = 0; - } - } - } + while (perdu != -1) { + if (!jeuEnPause) { + 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]++; + } + AfficheTemps(temps[0], temps[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; + case XK_space: + jeuEnPause = 1; + break; + case XK_Escape: + return EXIT_FAILURE; + } + } + DeplacerSerpent(&direction); + perdu = GestionCollision(perdu); + if (perdu == 1) { + GenererNouvellePomme(); + perdu = 0; + } + } else { + /* Le jeu est en pause*/ + if (ToucheEnAttente()) { + int touche = Touche(); + if (touche == XK_space) { + if(touche == XK_Escape){ + return EXIT_FAILURE; + } + jeuEnPause = 0; + } + } } + } - FermerGraphique(); - LibererMemoire(); - return EXIT_SUCCESS; + FermerGraphique(); + LibererMemoire(); + return EXIT_SUCCESS; } From d87143036ddc9b674c52397498d82b91e3479ade Mon Sep 17 00:00:00 2001 From: rognant Date: Tue, 12 Dec 2023 13:46:39 +0100 Subject: [PATCH 9/9] t --- #serpent.c# | 303 ------------------------------------- .#serpent.c | 1 - serpent.c | 424 +++++++++++++++++++++++++++------------------------- 3 files changed, 219 insertions(+), 509 deletions(-) delete mode 100644 #serpent.c# delete mode 120000 .#serpent.c diff --git a/#serpent.c# b/#serpent.c# deleted file mode 100644 index 236c563..0000000 --- a/#serpent.c# +++ /dev/null @@ -1,303 +0,0 @@ -#include -#include -#include -#include -#include - -#define HAUTEUR 40 -#define LARGEUR 60 -#define TAILLE_CASE 19 -#define NOMBRE_POMMES 5 -#define CYCLE 100000L - -typedef struct { - int x; - int y; -} Position; - -typedef struct { - Position* corps; - int longueur; -} Serpent; - -typedef struct { - Position* positions; - int nombre; -} Pommes; - -Serpent serpent; -Pommes pommes; - -int score = 0; -int perdu = 0; - -void Attendre(unsigned int millisecondes) { - usleep(millisecondes * 1000); -} - -void InitialiserJeu() { - serpent.longueur = 10; - serpent.corps = malloc(sizeof(Position) * serpent.longueur); - pommes.nombre = NOMBRE_POMMES; - - srand(time(NULL)); - - serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE; - serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE; - perdu = 0; /* Initialisation de la variable perdu*/ -} - -void Graphique() { - InitialiserGraphique(); - CreerFenetre(1, 1, 1240, 940); - EcrireTexte(500, 400, "Le jeu va commencer !", 2); - Attendre(1000); - EffacerEcran(CouleurParComposante(0, 0, 0)); -} - -void AffichageBasique() { - ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); - RemplirRectangle(0, 0, 1140, 760); -} - -void AfficherScore() { - char scoreText[20]; /* Correction de la taille du tableau*/ - snprintf(scoreText, 20, "Score: %d", score); - ChoisirCouleurDessin(CouleurParComposante(0, 0, 0)); - RemplirRectangle(20, 820, 150, 40); - ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); - EcrireTexte(20, 850, scoreText, 2); -} - -int PauseJeu() { - while (1) { - if (ToucheEnAttente()) { - int touche = Touche(); - if (touche == XK_space) { - return 1; /* La barre d'espace a été pressée, reprendre le jeu*/ - } - } - Attendre(100); - } -} - -void LibererMemoire() { - free(serpent.corps); - free(pommes.positions); -} - -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); -} - -void AfficherSerpent() { - couleur couleurSerpent = CouleurParComposante(255, 255, 0); - ChoisirCouleurDessin(couleurSerpent); - - for (int i = 0; i < serpent.longueur; i++) { - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); - } -} - -void GenererPommes() { - couleur couleurPommes = CouleurParComposante(255, 0, 0); - pommes.positions = malloc(sizeof(Position) * pommes.nombre); - - for (int i = 0; i < pommes.nombre; i++) { - pommes.positions[i].x = rand() % LARGEUR; - pommes.positions[i].y = rand() % HAUTEUR; - ChoisirCouleurDessin(couleurPommes); - RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); - } -} - -void GenererNouvellePomme() { - couleur couleurPommes = CouleurParComposante(255, 0, 0); - int i = rand() % pommes.nombre; /* Utilisation d'une position aléatoire*/ - pommes.positions[i].x = rand() % LARGEUR; - pommes.positions[i].y = rand() % HAUTEUR; - ChoisirCouleurDessin(couleurPommes); - RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); -} - -int CollisionAvecPomme() { - for (int i = 0; i < pommes.nombre; i++) { - /* Vérifier si la tête du serpent est à l'intérieur de la zone de la pomme*/ - if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE && - serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE && - serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE && - serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) { - GenererNouvellePomme(); /* Générer une nouvelle position pour la pomme mangée*/ - score= score +5; /* Augmenter le score*/ - AfficherScore(); /* Mettre à jour l'affichage du score*/ - return 1; - } - } - return 0; -} - -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) { - perdu = -1; // Le serpent a perdu - return 1; - } - } - return 0; -} - -int CollisionAvecBordures() { - if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE || - serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) { - perdu = -1; // Le serpent a perdu - return 1; - } - return 0; -} - -void DeplacerSerpent(int* direction) { - couleur couleurFond = CouleurParComposante(0, 0, 0); - couleur couleurSerpent = CouleurParComposante(255, 255, 0); - couleur couleurTerrain = CouleurParComposante(111, 255, 94); - - for (int i = 0; i < serpent.longueur; i++) { - ChoisirCouleurDessin(couleurTerrain); - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); - } - - for (int i = serpent.longueur - 1; i > 0; i--) { - serpent.corps[i] = serpent.corps[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; - } - } - - 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; - } - - for (int i = 0; i < serpent.longueur; i++) { - ChoisirCouleurDessin(couleurSerpent); - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); - } - - Attendre(100); -} - -int GestionCollision(int perdu) { - int loose = perdu; - if (CollisionAvecPomme()) { - serpent.longueur = serpent.longueur +2; - serpent.corps = realloc(serpent.corps, sizeof(Position) * serpent.longueur); - loose = 1; - } - if (CollisionAvecSerpent() || CollisionAvecBordures()) { - loose = -1; /* Le serpent a perdu*/ - } - /*printf("%d \n", loose);*/ - return loose; -} - -int main() { - int direction = 1; - unsigned long suivant = Microsecondes() + CYCLE; - int temps[2] = {0, 0}, seconde_actuel, old_seconde; - int jeuEnPause = 0; - int perdu = 0; - - InitialiserJeu(); - Graphique(); - EffacerEcran(CouleurParComposante(0, 0, 0)); - AffichageBasique(); - GenererPommes(); - AfficherSerpent(); - AfficherScore(); - - while (perdu != -1) { - if (!jeuEnPause) { - 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]++; - } - AfficheTemps(temps[0], temps[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; - case XK_space: - jeuEnPause = 1; - break; - case XK_Escape: - return EXIT_FAILURE; - } - } - DeplacerSerpent(&direction); - perdu = GestionCollision(perdu); - if (perdu == 1) { - GenererNouvellePomme(); - perdu = 0; - } - } else { - /* Le jeu est en pause*/ - if (ToucheEnAttente()) { - int touche = Touche(); - if (touche == XK_space) { - if(touche == XK_Escape){ - return EXIT_FAILURE; - } - jeuEnPause = 0; - } - } - } - } - - FermerGraphique(); - LibererMemoire(); - return EXIT_SUCCESS; -} diff --git a/.#serpent.c b/.#serpent.c deleted file mode 120000 index 4a26999..0000000 --- a/.#serpent.c +++ /dev/null @@ -1 +0,0 @@ -rognant@salle235-14.17429:1702034892 \ No newline at end of file diff --git a/serpent.c b/serpent.c index 18c0b12..a50f74f 100644 --- a/serpent.c +++ b/serpent.c @@ -8,6 +8,7 @@ #define LARGEUR 60 #define TAILLE_CASE 19 #define NOMBRE_POMMES 5 +#define NOMBRE_OBSTACLES 20 #define CYCLE 100000L typedef struct { @@ -25,279 +26,292 @@ typedef struct { int nombre; } Pommes; +typedef struct { + Position* positions; + int nombre; +} Obstacles; + +pomme[i-1].position=pomme[i].position + Serpent serpent; Pommes pommes; +Obstacles obstacles; -int score = 0; +int score = 0; int perdu = 0; void Attendre(unsigned int millisecondes) { - usleep(millisecondes * 1000); + usleep(millisecondes * 1000); } void InitialiserJeu() { - serpent.longueur = 10; - serpent.corps = malloc(sizeof(Position) * serpent.longueur); - pommes.nombre = NOMBRE_POMMES; + serpent.longueur = 10; + serpent.corps = malloc(sizeof(Position) * serpent.longueur); + pommes.nombre = NOMBRE_POMMES; + obstacles.nombre = NOMBRE_OBSTACLES; - srand(time(NULL)); + srand(time(NULL)); - serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE; - serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE; - perdu = 0; /* Initialisation de la variable perdu*/ + serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE; + serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE; + perdu = 0; + + // Initialisation des obstacles + obstacles.positions = malloc(sizeof(Position) * obstacles.nombre); + for (int i = 0; i < obstacles.nombre; i++) { + obstacles.positions[i].x = rand() % LARGEUR; + obstacles.positions[i].y = rand() % HAUTEUR; + } +} + +void GenererObstacles() { + couleur couleurObstacle = CouleurParComposante(0, 0, 255); + + for (int i = 0; i < obstacles.nombre; i++) { + ChoisirCouleurDessin(couleurObstacle); + RemplirRectangle(obstacles.positions[i].x * TAILLE_CASE, obstacles.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); + } } void Graphique() { - InitialiserGraphique(); - CreerFenetre(1, 1, 1240, 940); - EcrireTexte(500, 400, "Le jeu va commencer !", 2); - Attendre(1000); - EffacerEcran(CouleurParComposante(0, 0, 0)); + InitialiserGraphique(); + CreerFenetre(1, 1, 1240, 940); + EcrireTexte(500, 400, "Le jeu va commencer !", 2); + Attendre(1000); + EffacerEcran(CouleurParComposante(0, 0, 0)); } void AffichageBasique() { - ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); - RemplirRectangle(0, 0, 1140, 760); + ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); + RemplirRectangle(0, 0, 1140, 760); } void AfficherScore() { - char scoreText[20]; /* Correction de la taille du tableau*/ - snprintf(scoreText, 20, "Score: %d", score); - ChoisirCouleurDessin(CouleurParComposante(0, 0, 0)); - RemplirRectangle(20, 820, 150, 40); - ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); - EcrireTexte(20, 850, scoreText, 2); + char scoreText[20]; + snprintf(scoreText, 20, "Score: %d", score); + ChoisirCouleurDessin(CouleurParComposante(0, 0, 0)); + RemplirRectangle(20, 820, 150, 40); + ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); + EcrireTexte(20, 850, scoreText, 2); } int PauseJeu() { - while (1) { - if (ToucheEnAttente()) { - int touche = Touche(); - if (touche == XK_space) { - return 1; /* La barre d'espace a été pressée, reprendre le jeu*/ - } + while (1) { + if (ToucheEnAttente()) { + int touche = Touche(); + if (touche == XK_space) { + return 1; // La barre d'espace a été pressée, reprendre le jeu + } + } + Attendre(100); } - Attendre(100); - } } void LibererMemoire() { - free(serpent.corps); - free(pommes.positions); + free(serpent.corps); + free(pommes.positions); + free(obstacles.positions); } 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); + 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); } void AfficherSerpent() { - couleur couleurSerpent = CouleurParComposante(255, 255, 0); - ChoisirCouleurDessin(couleurSerpent); + couleur couleurSerpent = CouleurParComposante(255, 255, 0); + ChoisirCouleurDessin(couleurSerpent); - for (int i = 0; i < serpent.longueur; i++) { - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, 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); + } } void GenererPommes() { - couleur couleurPommes = CouleurParComposante(255, 0, 0); - pommes.positions = malloc(sizeof(Position) * pommes.nombre); - - for (int i = 0; i < pommes.nombre; i++) { + couleur couleurPommes = CouleurParComposante(255, 0, 0); + pommes.positions = malloc(sizeof(Position) * pommes.nombre); + + for (int i = 0; i < pommes.nombre; i++) { + pommes.positions[i].x = rand() % LARGEUR; + pommes.positions[i].y = rand() % HAUTEUR; + ChoisirCouleurDessin(couleurPommes); + RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); + } +} + +void GenererNouvellePomme() { + couleur couleurPommes = CouleurParComposante(255, 0, 0); + int i = rand() % pommes.nombre; pommes.positions[i].x = rand() % LARGEUR; pommes.positions[i].y = rand() % HAUTEUR; ChoisirCouleurDessin(couleurPommes); RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); - } -} - -void GenererNouvellePomme() { - couleur couleurPommes = CouleurParComposante(255, 0, 0); - int i = rand() % pommes.nombre; /* Utilisation d'une position aléatoire*/ - pommes.positions[i].x = rand() % LARGEUR; - pommes.positions[i].y = rand() % HAUTEUR; - ChoisirCouleurDessin(couleurPommes); - RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); } int CollisionAvecPomme() { - for (int i = 0; i < pommes.nombre; i++) { - /* Vérifier si la tête du serpent est à l'intérieur de la zone de la pomme*/ - if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE && - serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE && - serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE && - serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) { - GenererNouvellePomme(); /* Générer une nouvelle position pour la pomme mangée*/ - score= score +5; /* Augmenter le score*/ - AfficherScore(); /* Mettre à jour l'affichage du score*/ - return 1; + for (int i = 0; i < pommes.nombre; i++) { + if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE && + serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE && + serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE && + serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) { + GenererNouvellePomme(); + score = score + 5; + AfficherScore(); + return 1; + } } - } - return 0; + return 0; +} + +int CollisionAvecObstacle() { + for (int i = 0; i < obstacles.nombre; i++) { + if (serpent.corps[0].x == obstacles.positions[i].x * TAILLE_CASE && + serpent.corps[0].y == obstacles.positions[i].y * TAILLE_CASE) { + perdu = -1; // Le serpent a perdu + return 1; + } + } + return 0; } 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) { - perdu = -1; // Le serpent a perdu - return 1; + 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) { + perdu = -1; + return 1; + } } - } - return 0; + return 0; } int CollisionAvecBordures() { - if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE || - serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) { - perdu = -1; // Le serpent a perdu - return 1; - } - return 0; + if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE || + serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) { + perdu = -1; + return 1; + } + return 0; } void DeplacerSerpent(int* direction) { - couleur couleurFond = CouleurParComposante(0, 0, 0); - couleur couleurSerpent = CouleurParComposante(255, 255, 0); - couleur couleurTerrain = CouleurParComposante(111, 255, 94); - - for (int i = 0; i < serpent.longueur; i++) { - ChoisirCouleurDessin(couleurTerrain); - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); - } - - for (int i = serpent.longueur - 1; i > 0; i--) { - serpent.corps[i] = serpent.corps[i - 1]; - } + couleur couleurFond = CouleurParComposante(0, 0, 0); + couleur couleurSerpent = CouleurParComposante(255, 255, 0); + couleur couleurTerrain = CouleurParComposante(111, 255, 94); - 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; + for (int i = 0; i < serpent.longueur; i++) { + ChoisirCouleurDessin(couleurTerrain); + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); } - } - 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; - } + for (int i = serpent.longueur - 1; i > 0; i--) { + serpent.corps[i] = serpent.corps[i - 1]; + } - for (int i = 0; i < serpent.longueur; i++) { - ChoisirCouleurDessin(couleurSerpent); - RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); - } + 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; + } - Attendre(100); + for (int i = 0; i < serpent.longueur; i++) { + ChoisirCouleurDessin(couleurSerpent); + RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE); + } + + Attendre(100); } int GestionCollision(int perdu) { - int loose = perdu; - if (CollisionAvecPomme()) { - serpent.longueur = serpent.longueur +2; - serpent.corps = realloc(serpent.corps, sizeof(Position) * serpent.longueur); - loose = 1; - } - if (CollisionAvecSerpent() || CollisionAvecBordures()) { - loose = -1; /* Le serpent a perdu*/ - } - /*printf("%d \n", loose);*/ - return loose; + int loose = perdu; + if (CollisionAvecPomme()) { + serpent.longueur = serpent.longueur + 2; + serpent.corps = realloc(serpent.corps, sizeof(Position) * serpent.longueur); + loose = 1; + } + if (CollisionAvecObstacle() || CollisionAvecSerpent() || CollisionAvecBordures()) { + loose = -1; + } + return loose; } int main() { - int direction = 1; - unsigned long suivant = Microsecondes() + CYCLE; - int temps[2] = {0, 0}, seconde_actuel, old_seconde; - int jeuEnPause = 0; - int perdu = 0; + int direction = 1; + unsigned long suivant = Microsecondes() + CYCLE; + int temps[2] = {0, 0}, seconde_actuel, old_seconde; + int jeuEnPause = 0; + int perdu = 0; - InitialiserJeu(); - Graphique(); - EffacerEcran(CouleurParComposante(0, 0, 0)); - AffichageBasique(); - GenererPommes(); - AfficherSerpent(); - AfficherScore(); + InitialiserJeu(); + Graphique(); + EffacerEcran(CouleurParComposante(0, 0, 0)); + AffichageBasique(); + GenererPommes(); + GenererObstacles(); // Ajout de la génération des obstacles + AfficherSerpent(); + AfficherScore(); - while (perdu != -1) { - if (!jeuEnPause) { - 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]++; - } - AfficheTemps(temps[0], temps[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; - case XK_space: - jeuEnPause = 1; - break; - case XK_Escape: - return EXIT_FAILURE; - } - } - DeplacerSerpent(&direction); - perdu = GestionCollision(perdu); - if (perdu == 1) { - GenererNouvellePomme(); - perdu = 0; - } - } else { - /* Le jeu est en pause*/ - if (ToucheEnAttente()) { - int touche = Touche(); - if (touche == XK_space) { - if(touche == XK_Escape){ - return EXIT_FAILURE; - } - jeuEnPause = 0; - } - } + while (perdu != -1) { + if (!jeuEnPause) { + 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]++; + } + AfficheTemps(temps[0], temps[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; + case XK_space: + jeuEnPause = 1; + break; + case XK_Escape: + return EXIT_FAILURE; + } + } + DeplacerSerpent(&direction); + perdu = GestionCollision(perdu); + } else { + if (ToucheEnAttente()) { + int touche = Touche(); + if (touche == XK_space) { + if (touche == XK_Escape) { + return EXIT_FAILURE; + } + jeuEnPause = 0; + } + } + } } - } - FermerGraphique(); - LibererMemoire(); - return EXIT_SUCCESS; + FermerGraphique(); + LibererMemoire(); + return EXIT_SUCCESS; }