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