SAE11_2023/serpent.c

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

#define HAUTEUR 40
#define LARGEUR 60
#define TAILLE_CASE 19
#define NOMBRE_POMMES 5
#define NOMBRE_OBSTACLES 20
#define CYCLE 100000L

typedef struct {
    int x;
    int y;
} Position;

typedef struct {
    Position* corps;
    int longueur;
} Serpent;

typedef struct {
    Position* positions;
    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 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;
    obstacles.nombre = NOMBRE_OBSTACLES;

    srand(time(NULL));

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

void AffichageBasique() {
    ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
    RemplirRectangle(0, 0, 1140, 760);
}

void AfficherScore() {
    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
            }
        }
        Attendre(100);
    }
}

void LibererMemoire() {
    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);
}

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;
    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++) {
        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;
}

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;
            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;
        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 (*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 (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;

    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);
        } else {
            if (ToucheEnAttente()) {
                int touche = Touche();
                if (touche == XK_space) {
                    if (touche == XK_Escape) {
                        return EXIT_FAILURE;
                    }
                    jeuEnPause = 0;
                }
            }
        }
    }

    FermerGraphique();
    LibererMemoire();
    return EXIT_SUCCESS;
}