SAE11_2023/test.c

#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include <time.h>

#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;
}