mommeja/SAE11_2023
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

t

Browse Source
This commit is contained in:
Thomas ROGNANT 2023-12-18 14:51:12 +01:00
parent 3af41494e5
commit 5248a8a2a9
11 changed files with 5 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
graphique.c
View File

@ -3,22 +3,17 @@
#include "pommes.h" #include "pommes.h"
#include "obstacles.h" #include "obstacles.h"
#include <time.h> #include <time.h>
void Attendre(unsigned int millisecondes) { void Attendre(unsigned int millisecondes) {
usleep(millisecondes * 1000); usleep(millisecondes * 1000);
} }
void InitialiserJeu(Serpent* serpent, Pommes* pommes, Obstacles* obstacles) { void InitialiserJeu(Serpent* serpent, Pommes* pommes, Obstacles* obstacles) {
serpent->longueur = 10; serpent->longueur = 10;
serpent->corps = malloc(sizeof(Position) * serpent->longueur); serpent->corps = malloc(sizeof(Position) * serpent->longueur);
pommes->nombre = NOMBRE_POMMES; pommes->nombre = NOMBRE_POMMES;
obstacles->nombre = NOMBRE_OBSTACLES; obstacles->nombre = NOMBRE_OBSTACLES;
srand(time(NULL)); srand(time(NULL));
serpent->corps[0].x = LARGEUR / 2 * TAILLE_CASE; serpent->corps[0].x = LARGEUR / 2 * TAILLE_CASE;
serpent->corps[0].y = HAUTEUR / 2 * TAILLE_CASE; serpent->corps[0].y = HAUTEUR / 2 * TAILLE_CASE;
/* Initialisation des obstacles*/ /* Initialisation des obstacles*/
obstacles->positions = malloc(sizeof(Position) * obstacles->nombre); obstacles->positions = malloc(sizeof(Position) * obstacles->nombre);
for (int i = 0; i < obstacles->nombre; i++) { for (int i = 0; i < obstacles->nombre; i++) {
@ -26,7 +21,6 @@ void InitialiserJeu(Serpent* serpent, Pommes* pommes, Obstacles* obstacles) {
obstacles->positions[i].y = rand() % HAUTEUR; obstacles->positions[i].y = rand() % HAUTEUR;
} }
} }
void AfficherSerpent(Serpent* serpent) { void AfficherSerpent(Serpent* serpent) {
couleur couleurSerpent = CouleurParComposante(255, 255, 0); couleur couleurSerpent = CouleurParComposante(255, 255, 0);
ChoisirCouleurDessin(couleurSerpent); ChoisirCouleurDessin(couleurSerpent);
@ -34,13 +28,11 @@ void AfficherSerpent(Serpent* serpent) {
RemplirRectangle(serpent->corps[i].x, serpent->corps[i].y, TAILLE_CASE, TAILLE_CASE); RemplirRectangle(serpent->corps[i].x, serpent->corps[i].y, TAILLE_CASE, TAILLE_CASE);
} }
} }
void LibererMemoire(Serpent* serpent, Pommes* pommes, Obstacles* obstacles) { void LibererMemoire(Serpent* serpent, Pommes* pommes, Obstacles* obstacles) {
free(serpent->corps); free(serpent->corps);
LibererPommes(pommes); LibererPommes(pommes);
free(obstacles->positions); free(obstacles->positions);
} }
void Graphique() { void Graphique() {
InitialiserGraphique(); InitialiserGraphique();
CreerFenetre(0, 0, 1240, 940); CreerFenetre(0, 0, 1240, 940);
@ -48,12 +40,10 @@ void Graphique() {
Attendre(1000); Attendre(1000);
EffacerEcran(CouleurParComposante(0, 0, 0)); EffacerEcran(CouleurParComposante(0, 0, 0));
} }
void AffichageBasique() { void AffichageBasique() {
ChoisirCouleurDessin(CouleurParComposante(111, 255, 94)); ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
RemplirRectangle(0, 0, 1140, 760); RemplirRectangle(0, 0, 1140, 760);
} }
void AfficherScore(int score) { void AfficherScore(int score) {
char scoreText[20]; char scoreText[20];
snprintf(scoreText, 20, "Score: %d", score); snprintf(scoreText, 20, "Score: %d", score);
@ -62,7 +52,6 @@ void AfficherScore(int score) {
ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
EcrireTexte(20, 850, scoreText, 2); EcrireTexte(20, 850, scoreText, 2);
} }
void AfficheTemps(int minute, int seconde) { void AfficheTemps(int minute, int seconde) {
char temps[6]; char temps[6];
snprintf(temps, 6, "%02d:%02d", minute, seconde); snprintf(temps, 6, "%02d:%02d", minute, seconde);
@ -71,17 +60,15 @@ void AfficheTemps(int minute, int seconde) {
ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
EcrireTexte(20, 900, temps, 2); EcrireTexte(20, 900, temps, 2);
} }
void AfficherEcranFin(int score) { void AfficherEcranFin(int score) {
EffacerEcran(CouleurParComposante(0, 0, 0));
EcrireTexte(500, 300, "Game Over!", 2); EcrireTexte(500, 300, "Game Over!", 2);
char scoreText[20]; char scoreText[20];
snprintf(scoreText, 20, "Score: %d", score); snprintf(scoreText, 20, "Score: %d", score);
EcrireTexte(500, 400, scoreText, 2); EcrireTexte(500, 400, scoreText, 2);
}
int PauseJeu() { }
while (1) { int PauseJeu(int perdu) {
while (perdu != -1) {
if (ToucheEnAttente()) { if (ToucheEnAttente()) {
int touche = Touche(); int touche = Touche();
if (touche == XK_space) { if (touche == XK_space) {

6
graphique.h
View File

@ -1,23 +1,19 @@
#ifndef GRAPHIQUE_H #ifndef GRAPHIQUE_H
#define GRAPHIQUE_H #define GRAPHIQUE_H
#include <graph.h> #include <graph.h>
#include "serpent.h" #include "serpent.h"
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#define NOMBRE_POMMES 5 #define NOMBRE_POMMES 5
#define NOMBRE_OBSTACLES 20 #define NOMBRE_OBSTACLES 20
void Attendre(unsigned int millisecondes); void Attendre(unsigned int millisecondes);
void Graphique(); void Graphique();
void AffichageBasique(); void AffichageBasique();
void AfficherScore(int score); void AfficherScore(int score);
void AfficheTemps(int minute, int seconde); void AfficheTemps(int minute, int seconde);
void AfficherEcranFin(int score); void AfficherEcranFin(int score);
int PauseJeu(); int PauseJeu(int perdu);
void AfficherSerpent(Serpent* serpent); void AfficherSerpent(Serpent* serpent);
void InitialiserJeu(Serpent* serpent, Pommes* pommes, Obstacles* obstacles); void InitialiserJeu(Serpent* serpent, Pommes* pommes, Obstacles* obstacles);
void LibererMemoire(Serpent* serpent, Pommes* pommes, Obstacles* obstacles); void LibererMemoire(Serpent* serpent, Pommes* pommes, Obstacles* obstacles);
#endif #endif

7
main.c
View File

@ -1,4 +1,3 @@
#include "main.h" #include "main.h"
#include "serpent.h" #include "serpent.h"
#include "pommes.h" #include "pommes.h"
@ -6,7 +5,6 @@
#include "graphique.h" #include "graphique.h"
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int direction = 1; int direction = 1;
unsigned long suivant = Microsecondes() + CYCLE; unsigned long suivant = Microsecondes() + CYCLE;
@ -15,7 +13,6 @@ int main() {
Serpent serpent; Serpent serpent;
Pommes pommes; Pommes pommes;
Obstacles obstacles; Obstacles obstacles;
InitialiserJeu(&serpent, &pommes, &obstacles); InitialiserJeu(&serpent, &pommes, &obstacles);
Graphique(); Graphique();
EffacerEcran(CouleurParComposante(0, 0, 0)); EffacerEcran(CouleurParComposante(0, 0, 0));
@ -24,7 +21,6 @@ int main() {
GenererObstacles(&obstacles, &pommes, &serpent); GenererObstacles(&obstacles, &pommes, &serpent);
AfficherSerpent(&serpent); AfficherSerpent(&serpent);
AfficherScore(score); AfficherScore(score);
while (perdu != -1) { while (perdu != -1) {
if (!jeuEnPause) { if (!jeuEnPause) {
if (Microsecondes() > suivant) { if (Microsecondes() > suivant) {
@ -41,7 +37,6 @@ int main() {
AfficheTemps(temps[0], temps[1]); AfficheTemps(temps[0], temps[1]);
} }
} }
if (ToucheEnAttente()) { if (ToucheEnAttente()) {
int touche = Touche(); int touche = Touche();
int nouvelleDirection; int nouvelleDirection;
@ -65,7 +60,6 @@ int main() {
direction = nouvelleDirection; direction = nouvelleDirection;
} }
} }
DeplacerSerpent(&serpent, &direction); DeplacerSerpent(&serpent, &direction);
perdu = GestionCollision(&serpent, &pommes, &obstacles, perdu, &score); perdu = GestionCollision(&serpent, &pommes, &obstacles, perdu, &score);
} else { } else {
@ -80,7 +74,6 @@ int main() {
} }
} }
} }
LibererMemoire(&serpent, &pommes, &obstacles); LibererMemoire(&serpent, &pommes, &obstacles);
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }

4
main.h
View File

@ -1,18 +1,15 @@
#ifndef MAIN_H #ifndef MAIN_H
#define MAIN_H #define MAIN_H
#include "serpent.h" #include "serpent.h"
#include "pommes.h" #include "pommes.h"
#include "obstacles.h" #include "obstacles.h"
#include "graphique.h" #include "graphique.h"
#define HAUTEUR 40 #define HAUTEUR 40
#define LARGEUR 60 #define LARGEUR 60
#define TAILLE_CASE 19 #define TAILLE_CASE 19
#define NOMBRE_POMMES 5 #define NOMBRE_POMMES 5
#define NOMBRE_OBSTACLES 20 #define NOMBRE_OBSTACLES 20
#define CYCLE 100000L #define CYCLE 100000L
void Attendre(unsigned int millisecondes); void Attendre(unsigned int millisecondes);
void InitialiserJeu(Serpent* serpent, Pommes* pommes, Obstacles* obstacles); void InitialiserJeu(Serpent* serpent, Pommes* pommes, Obstacles* obstacles);
void AffichageBasique(); void AffichageBasique();
@ -25,5 +22,4 @@ void AfficherSerpent(Serpent* serpent);
void GenererObstacles(Obstacles* obstacles, Pommes* pommes, Serpent* serpent); void GenererObstacles(Obstacles* obstacles, Pommes* pommes, Serpent* serpent);
void DeplacerSerpent(Serpent* serpent, int* direction); void DeplacerSerpent(Serpent* serpent, int* direction);
int GestionCollision(Serpent* serpent, Pommes* pommes, Obstacles* obstacles, int perdu, int* score); int GestionCollision(Serpent* serpent, Pommes* pommes, Obstacles* obstacles, int perdu, int* score);
#endif #endif

5
obstacles.c
View File

@ -1,25 +1,20 @@
#include "obstacles.h" #include "obstacles.h"
void GenererObstacles(Obstacles* obstacles, Pommes* pommes, Serpent* serpent) { void GenererObstacles(Obstacles* obstacles, Pommes* pommes, Serpent* serpent) {
couleur couleurObstacle = CouleurParComposante(128, 128, 128); couleur couleurObstacle = CouleurParComposante(128, 128, 128);
obstacles->positions = (Position*)malloc(obstacles->nombre * sizeof(Position)); obstacles->positions = (Position*)malloc(obstacles->nombre * sizeof(Position));
if (obstacles->positions == NULL) { if (obstacles->positions == NULL) {
perror("Allocation error"); perror("Allocation error");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
for (int i = 0; i < obstacles->nombre; i++) { for (int i = 0; i < obstacles->nombre; i++) {
do { do {
obstacles->positions[i].x = rand() % LARGEUR; obstacles->positions[i].x = rand() % LARGEUR;
obstacles->positions[i].y = rand() % HAUTEUR; obstacles->positions[i].y = rand() % HAUTEUR;
} while (CollisionAvecPommeSerpent(obstacles->positions[i], pommes->head) || CollisionAvecSerpent(serpent)); } while (CollisionAvecPommeSerpent(obstacles->positions[i], pommes->head) || CollisionAvecSerpent(serpent));
ChoisirCouleurDessin(couleurObstacle); ChoisirCouleurDessin(couleurObstacle);
RemplirRectangle(obstacles->positions[i].x * TAILLE_CASE, obstacles->positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); RemplirRectangle(obstacles->positions[i].x * TAILLE_CASE, obstacles->positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
} }
} }
int CollisionAvecObstacle(Serpent* serpent, Obstacles* obstacles) { int CollisionAvecObstacle(Serpent* serpent, Obstacles* obstacles) {
for (int i = 0; i < obstacles->nombre; i++) { for (int i = 0; i < obstacles->nombre; i++) {
if (serpent->corps[0].x == obstacles->positions[i].x * TAILLE_CASE && if (serpent->corps[0].x == obstacles->positions[i].x * TAILLE_CASE &&

5
obstacles.h
View File

@ -1,19 +1,14 @@
#ifndef OBSTACLES_H #ifndef OBSTACLES_H
#define OBSTACLES_H #define OBSTACLES_H
#include "pommes.h" #include "pommes.h"
#include "serpent.h" #include "serpent.h"
#define LARGEUR 60 #define LARGEUR 60
#define HAUTEUR 40 #define HAUTEUR 40
#define TAILLE_CASE 19 #define TAILLE_CASE 19
typedef struct Obstacles { typedef struct Obstacles {
Position* positions; Position* positions;
int nombre; int nombre;
} Obstacles; } Obstacles;
void GenererObstacles(Obstacles* obstacles, Pommes* pommes, Serpent* serpent); void GenererObstacles(Obstacles* obstacles, Pommes* pommes, Serpent* serpent);
int CollisionAvecObstacle(Serpent* serpent, Obstacles* obstacles); int CollisionAvecObstacle(Serpent* serpent, Obstacles* obstacles);
#endif #endif

11
pommes.c
View File

@ -1,7 +1,6 @@
#include <stdlib.h> #include <stdlib.h>
#include <graph.h> #include <graph.h>
#include "pommes.h" #include "pommes.h"
void LibererPommes(Pommes* pommes) { void LibererPommes(Pommes* pommes) {
PommeNode* current = pommes->head; PommeNode* current = pommes->head;
while (current != NULL) { while (current != NULL) {
@ -11,55 +10,45 @@ void LibererPommes(Pommes* pommes) {
} }
pommes->head = NULL; pommes->head = NULL;
} }
void GenererPommes(Pommes* pommes) { void GenererPommes(Pommes* pommes) {
couleur couleurPommes = CouleurParComposante(255, 0, 0); couleur couleurPommes = CouleurParComposante(255, 0, 0);
pommes->head = NULL; pommes->head = NULL;
for (int i = 0; i < pommes->nombre; i++) { for (int i = 0; i < pommes->nombre; i++) {
PommeNode* nouvellePomme = (PommeNode*)malloc(sizeof(PommeNode)); PommeNode* nouvellePomme = (PommeNode*)malloc(sizeof(PommeNode));
if (nouvellePomme == NULL) { if (nouvellePomme == NULL) {
perror("Allocation error"); perror("Allocation error");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
nouvellePomme->position.x = rand() % LARGEUR; nouvellePomme->position.x = rand() % LARGEUR;
nouvellePomme->position.y = rand() % HAUTEUR; nouvellePomme->position.y = rand() % HAUTEUR;
nouvellePomme->next = pommes->head; nouvellePomme->next = pommes->head;
pommes->head = nouvellePomme; pommes->head = nouvellePomme;
ChoisirCouleurDessin(couleurPommes); ChoisirCouleurDessin(couleurPommes);
RemplirArc(nouvellePomme->position.x * TAILLE_CASE, nouvellePomme->position.y * TAILLE_CASE, RemplirArc(nouvellePomme->position.x * TAILLE_CASE, nouvellePomme->position.y * TAILLE_CASE,
TAILLE_CASE, TAILLE_CASE, 360, 360); TAILLE_CASE, TAILLE_CASE, 360, 360);
} }
} }
void AjouterPomme(Pommes* pommes, int x, int y) { void AjouterPomme(Pommes* pommes, int x, int y) {
PommeNode* nouvellePomme = (PommeNode*)malloc(sizeof(PommeNode)); PommeNode* nouvellePomme = (PommeNode*)malloc(sizeof(PommeNode));
if (nouvellePomme == NULL) { if (nouvellePomme == NULL) {
perror("Allocation error"); perror("Allocation error");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
nouvellePomme->position.x = x; nouvellePomme->position.x = x;
nouvellePomme->position.y = y; nouvellePomme->position.y = y;
nouvellePomme->next = pommes->head; nouvellePomme->next = pommes->head;
pommes->head = nouvellePomme; pommes->head = nouvellePomme;
pommes->nombre++; pommes->nombre++;
} }
void GenererNouvellePomme(Pommes* pommes) { void GenererNouvellePomme(Pommes* pommes) {
couleur couleurPommes = CouleurParComposante(255, 0, 0); couleur couleurPommes = CouleurParComposante(255, 0, 0);
int newX = rand() % LARGEUR; int newX = rand() % LARGEUR;
int newY = rand() % HAUTEUR; int newY = rand() % HAUTEUR;
// Assuming you have a function named AjouterPomme to add a new apple to the linked list. // Assuming you have a function named AjouterPomme to add a new apple to the linked list.
AjouterPomme(pommes, newX, newY); AjouterPomme(pommes, newX, newY);
ChoisirCouleurDessin(couleurPommes); ChoisirCouleurDessin(couleurPommes);
RemplirArc(newX * TAILLE_CASE, newY * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE, 360, 360); RemplirArc(newX * TAILLE_CASE, newY * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE, 360, 360);
} }
int CollisionAvecPommeSerpent(Position position, PommeNode* pommes) { int CollisionAvecPommeSerpent(Position position, PommeNode* pommes) {
PommeNode* current = pommes; PommeNode* current = pommes;
while (current != NULL) { while (current != NULL) {

6
pommes.h
View File

@ -1,29 +1,23 @@
#ifndef POMMES_H #ifndef POMMES_H
#define POMMES_H #define POMMES_H
#include "serpent.h" #include "serpent.h"
#include "graphique.h" #include "graphique.h"
#include <graph.h> #include <graph.h>
#define LARGEUR 60 #define LARGEUR 60
#define HAUTEUR 40 #define HAUTEUR 40
#define TAILLE_CASE 19 #define TAILLE_CASE 19
typedef struct PommeNode { typedef struct PommeNode {
Position position; Position position;
struct PommeNode* next; struct PommeNode* next;
} PommeNode; } PommeNode;
typedef struct Pommes { typedef struct Pommes {
PommeNode* head; PommeNode* head;
int nombre; int nombre;
} Pommes; } Pommes;
void LibererPommes(Pommes* pommes); void LibererPommes(Pommes* pommes);
void GenererPommes(Pommes* pommes); void GenererPommes(Pommes* pommes);
void AjouterPomme(Pommes* pommes, int x, int y); void AjouterPomme(Pommes* pommes, int x, int y);
void GenererNouvellePomme(Pommes* pommes); void GenererNouvellePomme(Pommes* pommes);
int CollisionAvecPommeSerpent(Position position, PommeNode* pommes); int CollisionAvecPommeSerpent(Position position, PommeNode* pommes);
int CollisionAvecPomme(Serpent* serpent, Pommes* pommes, int* score); int CollisionAvecPomme(Serpent* serpent, Pommes* pommes, int* score);
#endif #endif

16
serpent.c
View File

@ -1,22 +1,18 @@
#include "serpent.h" #include "serpent.h"
#include "pommes.h" #include "pommes.h"
void DeplacerSerpent(Serpent* serpent, int* direction) { void DeplacerSerpent(Serpent* serpent, int* direction) {
couleur couleurFond = CouleurParComposante(0, 0, 0); couleur couleurFond = CouleurParComposante(0, 0, 0);
couleur couleurSerpent = CouleurParComposante(255, 255, 0); couleur couleurSerpent = CouleurParComposante(255, 255, 0);
couleur couleurTerrain = CouleurParComposante(111, 255, 94); couleur couleurTerrain = CouleurParComposante(111, 255, 94);
// Clear the previous positions of the snake // Clear the previous positions of the snake
for (int i = 0; i < serpent->longueur; i++) { for (int i = 0; i < serpent->longueur; i++) {
ChoisirCouleurDessin(couleurTerrain); ChoisirCouleurDessin(couleurTerrain);
RemplirRectangle(serpent->corps[i].x, serpent->corps[i].y, TAILLE_CASE, TAILLE_CASE); RemplirRectangle(serpent->corps[i].x, serpent->corps[i].y, TAILLE_CASE, TAILLE_CASE);
} }
// Update the snake's body positions // Update the snake's body positions
for (int i = serpent->longueur - 1; i > 0; i--) { for (int i = serpent->longueur - 1; i > 0; i--) {
serpent->corps[i] = serpent->corps[i - 1]; serpent->corps[i] = serpent->corps[i - 1];
} }
// Move the snake's head based on the direction // Move the snake's head based on the direction
if (*direction == 1) { if (*direction == 1) {
serpent->corps[0].x += TAILLE_CASE; serpent->corps[0].x += TAILLE_CASE;
@ -27,44 +23,35 @@ void DeplacerSerpent(Serpent* serpent, int* direction) {
} else if (*direction == 4) { } else if (*direction == 4) {
serpent->corps[0].y += TAILLE_CASE; serpent->corps[0].y += TAILLE_CASE;
} }
// Draw the updated snake // Draw the updated snake
for (int i = 0; i < serpent->longueur; i++) { for (int i = 0; i < serpent->longueur; i++) {
ChoisirCouleurDessin(couleurSerpent); ChoisirCouleurDessin(couleurSerpent);
RemplirRectangle(serpent->corps[i].x, serpent->corps[i].y, TAILLE_CASE, TAILLE_CASE); RemplirRectangle(serpent->corps[i].x, serpent->corps[i].y, TAILLE_CASE, TAILLE_CASE);
} }
Attendre(100); Attendre(100);
} }
int GestionCollision(Serpent* serpent, Pommes* pommes, Obstacles* obstacles, int perdu, int* score) { int GestionCollision(Serpent* serpent, Pommes* pommes, Obstacles* obstacles, int perdu, int* score) {
int loose = perdu; int loose = perdu;
if (CollisionAvecPomme(serpent, pommes, score)) { if (CollisionAvecPomme(serpent, pommes, score)) {
serpent->longueur = serpent->longueur + 2; serpent->longueur = serpent->longueur + 2;
serpent->corps = realloc(serpent->corps, sizeof(Position) * serpent->longueur); serpent->corps = realloc(serpent->corps, sizeof(Position) * serpent->longueur);
loose = 1; loose = 1;
} }
if (CollisionAvecObstacle(serpent, obstacles) || CollisionAvecSerpent(serpent) || CollisionAvecBordures(serpent)) { if (CollisionAvecObstacle(serpent, obstacles) || CollisionAvecSerpent(serpent) || CollisionAvecBordures(serpent)) {
AfficherEcranFin(*score); AfficherEcranFin(*score);
Attendre(1000); Attendre(1000);
loose = -1; loose = -1;
} }
return loose; return loose;
} }
int CollisionAvecSerpent(Serpent* serpent) { int CollisionAvecSerpent(Serpent* serpent) {
for (int i = 1; i < serpent->longueur; i++) { 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) { if (serpent->corps[0].x == serpent->corps[i].x && serpent->corps[0].y == serpent->corps[i].y) {
return 1; return 1;
} }
} }
return 0; return 0;
} }
int EstDirectionOpposee(int directionActuelle, int nouvelleDirection) { int EstDirectionOpposee(int directionActuelle, int nouvelleDirection) {
if ((directionActuelle == 1 && nouvelleDirection == 2) || if ((directionActuelle == 1 && nouvelleDirection == 2) ||
(directionActuelle == 2 && nouvelleDirection == 1) || (directionActuelle == 2 && nouvelleDirection == 1) ||
@ -72,16 +59,13 @@ int EstDirectionOpposee(int directionActuelle, int nouvelleDirection) {
(directionActuelle == 4 && nouvelleDirection == 3)) { (directionActuelle == 4 && nouvelleDirection == 3)) {
return 1; // Les directions sont opposées return 1; // Les directions sont opposées
} }
return 0; // Les directions ne sont pas opposées return 0; // Les directions ne sont pas opposées
} }
int CollisionAvecBordures(Serpent* serpent) { int CollisionAvecBordures(Serpent* serpent) {
if (serpent->corps[0].x < 0 || serpent->corps[0].x >= LARGEUR * TAILLE_CASE || 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) { serpent->corps[0].y < 0 || serpent->corps[0].y >= HAUTEUR * TAILLE_CASE) {
return 1; return 1;
} }
return 0; return 0;
} }
int CollisionAvecPomme(Serpent* serpent, Pommes* pommes, int* score) { int CollisionAvecPomme(Serpent* serpent, Pommes* pommes, int* score) {

11
serpent.h
View File

@ -1,35 +1,24 @@
#ifndef SERPENT_H #ifndef SERPENT_H
#define SERPENT_H #define SERPENT_H
#include <graph.h> #include <graph.h>
#include <stdlib.h> #include <stdlib.h>
#define TAILLE_CASE 19 #define TAILLE_CASE 19
#define LARGEUR 60 #define LARGEUR 60
#define HAUTEUR 40 #define HAUTEUR 40
typedef struct { typedef struct {
int x; int x;
int y; int y;
} Position; } Position;
typedef struct { typedef struct {
Position* corps; Position* corps;
int longueur; int longueur;
} Serpent; } Serpent;
typedef struct Pommes Pommes; typedef struct Pommes Pommes;
typedef struct Obstacles Obstacles; typedef struct Obstacles Obstacles;
extern void DeplacerSerpent(Serpent* serpent, int* direction); extern void DeplacerSerpent(Serpent* serpent, int* direction);
extern int GestionCollision(Serpent* serpent, Pommes* pommes, Obstacles* obstacles, int perdu, int* score); extern int GestionCollision(Serpent* serpent, Pommes* pommes, Obstacles* obstacles, int perdu, int* score);
extern int CollisionAvecSerpent(Serpent* serpent); extern int CollisionAvecSerpent(Serpent* serpent);
extern int EstDirectionOpposee(int directionActuelle, int nouvelleDirection); extern int EstDirectionOpposee(int directionActuelle, int nouvelleDirection);
extern int CollisionAvecBordures(Serpent* serpent); extern int CollisionAvecBordures(Serpent* serpent);
int CollisionAvecPomme(Serpent* serpent, Pommes* pommes, int* score); int CollisionAvecPomme(Serpent* serpent, Pommes* pommes, int* score);
#endif // SERPENT_H #endif // SERPENT_H

BIN
snake
View File

Binary file not shown.