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

6
graphique.h
View File

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

7
main.c
View File

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

6
main.h
View File

@ -1,18 +1,15 @@
#ifndef MAIN_H
#define MAIN_H
#include "serpent.h"
#include "pommes.h"
#include "obstacles.h"
#include "graphique.h"
#define HAUTEUR 40
#define LARGEUR 60
#define TAILLE_CASE 19
#define NOMBRE_POMMES 5
#define NOMBRE_OBSTACLES 20
#define CYCLE 100000L
void Attendre(unsigned int millisecondes);
void InitialiserJeu(Serpent* serpent, Pommes* pommes, Obstacles* obstacles);
void AffichageBasique();
@ -25,5 +22,4 @@ void AfficherSerpent(Serpent* serpent);
void GenererObstacles(Obstacles* obstacles, Pommes* pommes, Serpent* serpent);
void DeplacerSerpent(Serpent* serpent, int* direction);
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"
void GenererObstacles(Obstacles* obstacles, Pommes* pommes, Serpent* serpent) {
couleur couleurObstacle = CouleurParComposante(128, 128, 128);
obstacles->positions = (Position*)malloc(obstacles->nombre * sizeof(Position));
if (obstacles->positions == NULL) {
perror("Allocation error");
exit(EXIT_FAILURE);
}
for (int i = 0; i < obstacles->nombre; i++) {
do {
obstacles->positions[i].x = rand() % LARGEUR;
obstacles->positions[i].y = rand() % HAUTEUR;
} while (CollisionAvecPommeSerpent(obstacles->positions[i], pommes->head) || CollisionAvecSerpent(serpent));
ChoisirCouleurDessin(couleurObstacle);
RemplirRectangle(obstacles->positions[i].x * TAILLE_CASE, obstacles->positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
}
}
int CollisionAvecObstacle(Serpent* serpent, Obstacles* obstacles) {
for (int i = 0; i < obstacles->nombre; i++) {
if (serpent->corps[0].x == obstacles->positions[i].x * TAILLE_CASE &&

5
obstacles.h
View File

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

11
pommes.c
View File

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

6
pommes.h
View File

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

16
serpent.c
View File

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

11
serpent.h
View File

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

BIN
snake
View File

Binary file not shown.