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-11 14:03:33 +01:00
parent a5c4d48b2d
commit 39e5aaa1d3
5 changed files with 430 additions and 703 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

168
essai.c
View File

@ -1,168 +0,0 @@
#include <stdlib.h>
#include <graph.h>
#include <time.h>
#include <stdio.h>
#include <unistd.h>
#define HAUTEUR 40
#define LARGEUR 60
#define TAILLE_CASE 20
#define NOMBRE_POMMES 5
typedef struct {
int x;
int y;
} Segment;
/* Fonction pour attendre un certain nombre de millisecondes */
void Attendre(unsigned int millisecondes) {
usleep(millisecondes * 1000);
}
/* 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));
}
/* Fonction pour afficher le serpent */
void afficherSerpent(Segment serpent[], int taille) {
couleur couleurSerpent = CouleurParComposante(255, 255, 0);
ChoisirCouleurDessin(couleurSerpent);
for (int i = 0; i < taille; i++) {
RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
}
}
/* Fonction pour générer les pommes */
void genererPommes(Segment pommes[]) {
for (int i = 0; i < NOMBRE_POMMES; i++) {
pommes[i].x = (rand() % LARGEUR) * TAILLE_CASE;
pommes[i].y = (rand() % HAUTEUR) * TAILLE_CASE;
ChoisirCouleurDessin(CouleurParComposante(255, 0, 0));
RemplirRectangle(pommes[i].x, pommes[i].y, TAILLE_CASE, TAILLE_CASE);
}
}
/* Fonction pour déplacer le serpent */
void deplacerSerpent(int longueurSerpent, Segment serpent[], int *direction) {
couleur c;
couleur v;
couleur s;
c = CouleurParComposante(0, 0, 0);
s = CouleurParComposante(255, 255, 0);
v = CouleurParComposante(111, 255, 94);
for (int i = 0; i < longueurSerpent; i++) {
ChoisirCouleurDessin(v);
RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
}
for (int i = longueurSerpent - 1; i > 0; i--) {
serpent[i] = serpent[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;
}
}
/* Déplace la tête en fonction de la direction */
if (*direction == 1) {
serpent[0].x += TAILLE_CASE;
} else if (*direction == 2) {
serpent[0].x -= TAILLE_CASE;
} else if (*direction == 3) {
serpent[0].y -= TAILLE_CASE;
} else if (*direction == 4) {
serpent[0].y += TAILLE_CASE;
}
for (int i = 0; i < longueurSerpent; i++) {
ChoisirCouleurDessin(s);
RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
}
Attendre(100);
}
/* Fonction pour gérer les collisions */
int gererCollisions(Segment snake[], int *taille, Segment pommes[]) {
/* Vérifie la collision avec la pomme */
for (int i = 0; i < NOMBRE_POMMES; i++) {
if (snake[0].x == pommes[i].x && snake[0].y == pommes[i].y) {
/* Augmente la taille du serpent et génère une nouvelle pomme */
(*taille)++;
genererPommes(pommes);
return 1; /* Le serpent a mangé une pomme */
}
}
/* Vérifie la collision avec les parois */
if (snake[0].x < 0 || snake[0].x >= LARGEUR * TAILLE_CASE || snake[0].y < 0 || snake[0].y >= HAUTEUR * TAILLE_CASE) {
return -1; /* Collision avec la paroi */
}
/* Vérifie la collision avec le corps du serpent */
for (int i = 1; i < *taille; i++) {
if (snake[0].x == snake[i].x && snake[0].y == snake[i].y) {
return -1; /* Collision avec le corps du serpent */
}
}
return 0; /* Pas de collision */
}
int main() {
int perdu = 0, direction = 1, longueurSerpent = 10;
Segment serpent[LARGEUR * HAUTEUR];
Segment pommes[NOMBRE_POMMES];
couleur c = CouleurParComposante(0, 0, 0);
couleur v = CouleurParComposante(111, 255, 94);
couleur s = CouleurParComposante(255, 255, 0);
srand(time(NULL));
/* Position initiale du serpent au milieu du tableau */
serpent[0].x = LARGEUR / 2 * TAILLE_CASE;
serpent[0].y = HAUTEUR / 2 * TAILLE_CASE;
Graphique();
InitialiserGraphique();
CreerFenetre(10, 10, 1200, 820);
EffacerEcran(c);
AffichageBasique();
genererPommes(pommes);
afficherSerpent(serpent, longueurSerpent);
while (perdu != -1) {
deplacerSerpent(longueurSerpent, serpent, &direction);
perdu = gererCollisions(serpent, &longueurSerpent, pommes);
if (perdu == -1) {
printf("Vous avez perdu ! Collision avec la paroi ou le corps du serpent.\n");
FermerGraphique();
}
}
/* Attend que l'utilisateur appuie sur une touche avant de fermer la fenêtre graphique */
Touche();
FermerGraphique();
return EXIT_SUCCESS;
}

169
essai.c~
View File

@ -1,169 +0,0 @@
#include <stdlib.h>
#include <graph.h>
#include <time.h>
#include <unistd.h> // Ajout de l'en-tête pour usleep
#include <stdio.h>
#define HAUTEUR 40
#define LARGEUR 60
#define TAILLE_CASE 20
#define ESPACE_HAUT 35
#define ESPACE_BAS 85
#define NOMBRE_POMMES 5
#define CYCLE 100000L
typedef struct {
int x;
int y;
} Segment;
/* Fonction pour attendre un certain nombre de millisecondes */
void Attendre(unsigned int millisecondes) {
usleep(millisecondes * 1000);
}
/* 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));
}
/* Fonction pour afficher le serpent */
void afficherSerpent(Segment serpent[], int taille) {
int i;
couleur couleurSerpent = CouleurParNom("yellow");
ChoisirCouleurDessin(couleurSerpent);
for (i = 0; i < taille; i++) {
RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
}
}
/* Fonction pour générer les pommes */
void genererPommes(Segment pommes[]) {
for (int i = 0; i < NOMBRE_POMMES; i++) {
pommes[i].x = rand() % LARGEUR * TAILLE_CASE;
pommes[i].y = rand() % HAUTEUR * TAILLE_CASE;
ChoisirCouleurDessin(CouleurParComposante(255, 0, 0));
RemplirRectangle(pommes[i].x, pommes[i].y, TAILLE_CASE, TAILLE_CASE);
}
}
/* Fonction pour déplacer le serpent */
void deplacerSerpent(int longueurSerpent, Segment serpent[], int *direction) {
int i;
couleur c;
couleur v;
couleur s;
c = CouleurParComposante(0, 0, 0);
s = CouleurParComposante(255, 255, 0);
v = CouleurParComposante(111, 255, 94);
for (i = 0; i < longueurSerpent; i++) {
ChoisirCouleurDessin(v);
RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
}
for (i = longueurSerpent - 1; i > 0; i--) {
serpent[i] = serpent[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;
}
}
/* Déplace la tête en fonction de la direction */
if (*direction == 1) {
serpent[0].x += TAILLE_CASE;
} else if (*direction == 2) {
serpent[0].x -= TAILLE_CASE;
} else if (*direction == 3) {
serpent[0].y -= TAILLE_CASE;
} else if (*direction == 4) {
serpent[0].y += TAILLE_CASE;
}
for (i = 0; i < longueurSerpent; i++) {
ChoisirCouleurDessin(s);
RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
}
Attendre(100);
}
/* Fonction pour gérer les collisions */
int gererCollisions(Segment snake[], int *taille, Segment pommes[], int *aMangerPomme) {
/* Vérifie la collision avec la pomme */
for (int i = 0; i < NOMBRE_POMMES; i++) {
if (snake[0].x == pommes[i].x && snake[0].y == pommes[i].y) {
/* Augmente la taille du serpent et génère une nouvelle pomme */
(*taille)++;
*aMangerPomme = 1;
genererPommes(pommes);
return 1; /* Le serpent a mangé une pomme */
}
}
/* Vérifie la collision avec les parois */
if (snake[0].x <= 0 || snake[0].x >= LARGEUR * TAILLE_CASE || snake[0].y <= 0 || snake[0].y >= HAUTEUR * TAILLE_CASE) {
return -1; /* Collision avec la paroi */
}
/* Vérifie la collision avec le corps du serpent */
for (int i = 1; i < *taille; i++) {
if (snake[0].x == snake[i].x && snake[0].y == snake[i].y) {
return -1; /* Collision avec le corps du serpent */
}
}
return 0; /* Pas de collision */
}
/* Fonction pour afficher un fond basique */
void AffichageBasique() {
ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
RemplirRectangle(10, 10, TAILLE_CASE * LARGEUR, TAILLE_CASE * LARGEUR);
}
int main() {
int touche, perdu = 0, direction = 1, longueurSerpent = 10;
Segment serpent[LARGEUR * HAUTEUR];
Segment pommes[NOMBRE_POMMES];
couleur c = CouleurParComposante(0, 0, 0);
couleur v = CouleurParComposante(111, 255, 94);
couleur s = CouleurParComposante(255, 255, 0);
srand(time(NULL));
Graphique();
InitialiserGraphique();
CreerFenetre(10, 10, 1200, 820);
EffacerEcran(c);
AffichageBasique();
genererPommes(pommes);
afficherSerpent(serpent, longueurSerpent);
while (perdu != -1) {
deplacerSerpent(longueurSerpent, serpent, &direction);
perdu = gererCollisions(serpent, &longueurSerpent, pommes, &direction);
if (perdu == -1) {
printf("Vous avez perdu ! Collision avec la paroi ou le corps du serpent.\n");
FermerGraphique();
}
}
Touche();
FermerGraphique();
return EXIT_SUCCESS;
}

301
serpent.c
View File

@ -2,44 +2,101 @@
#include <graph.h> #include <graph.h>
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h>
#define HAUTEUR 40 #define HAUTEUR 40
#define LARGEUR 60 #define LARGEUR 60
#define TAILLE_CASE 20 #define TAILLE_CASE 19
#define NOMBRE_POMMES 5 #define NOMBRE_POMMES 5
#define CYCLE 100000L #define CYCLE 100000L
typedef struct { typedef struct {
int x; int x;
int y; int y;
} Segment; } Position;
typedef struct {
int x;
int y;
} Pomme;
typedef struct { typedef struct {
Position* corps;
int longueur; int longueur;
Segment* corps;
} Serpent; } Serpent;
typedef struct {
Position* positions;
int nombre;
} Pommes;
Serpent serpent;
Pommes pommes;
int score = 0; // Ajout de la variable score
int perdu = 0; // Variable pour indiquer si le serpent a perdu
void Attendre(unsigned int millisecondes) { void Attendre(unsigned int millisecondes) {
usleep(millisecondes * 1000); usleep(millisecondes * 1000);
} }
/* Fonction pour concevoir le graphique */ 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() { void Graphique() {
InitialiserGraphique(); InitialiserGraphique();
CreerFenetre(10, 10, 1240, 940); CreerFenetre(1, 1, 1240, 940);
EcrireTexte(500, 400, "Le jeu va commencer !", 2); EcrireTexte(500, 400, "Le jeu va commencer !", 2);
sleep(1); Attendre(1000);
EffacerEcran(CouleurParComposante(0, 0, 0)); EffacerEcran(CouleurParComposante(0, 0, 0));
} }
/* Fonction permettant d'afficher le serpent */ void AffichageBasique() {
void afficherSerpent(Serpent serpent) { ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
couleur couleurSerpent = CouleurParNom("yellow"); RemplirRectangle(0, 0, 1175, 775);
}
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); ChoisirCouleurDessin(couleurSerpent);
for (int i = 0; i < serpent.longueur; i++) { for (int i = 0; i < serpent.longueur; i++) {
@ -47,72 +104,74 @@ void afficherSerpent(Serpent serpent) {
} }
} }
void genererPommes(Pomme pommes[]) { void GenererPommes() {
for (int i = 0; i < NOMBRE_POMMES; i++) { couleur couleurPommes = CouleurParComposante(255, 0, 0);
pommes[i].x = rand() % LARGEUR * TAILLE_CASE; pommes.positions = malloc(sizeof(Position) * pommes.nombre);
pommes[i].y = rand() % HAUTEUR * TAILLE_CASE;
ChoisirCouleurDessin(CouleurParComposante(255, 0, 0)); for (int i = 0; i < pommes.nombre; i++) {
RemplirRectangle(pommes[i].x, pommes[i].y, TAILLE_CASE, TAILLE_CASE); 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);
} }
} }
/* Fonction initialisant la fenetre de jeux en vert */ void GenererNouvellePomme() {
void EcranJeu() { couleur couleurPommes = CouleurParComposante(255, 0, 0);
couleur v = CouleurParNom("light green"); int i = rand() % pommes.nombre; // Utilisation d'une position aléatoire
for (int i = 2; i < 42; i++) { pommes.positions[i].x = rand() % LARGEUR;
for (int j = 5; j < 65; j++) { pommes.positions[i].y = rand() % HAUTEUR;
ChoisirCouleurDessin(v); ChoisirCouleurDessin(couleurPommes);
RemplirRectangle(j * TAILLE_CASE, i * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
}
}
} }
int collisionAvecPomme(Serpent serpent, Pomme pomme) { int CollisionAvecPomme() {
return (serpent.corps[0].x == pomme.x && serpent.corps[0].y == pomme.y); 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 &&
int collisionAvecBordures(Serpent serpent) { serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE &&
return (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE || serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE &&
serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * 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
int collisionAvecSerpent(Serpent serpent) { AfficherScore(); // Mettre à jour l'affichage du score
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 1;
} }
} }
return 0; return 0;
} }
void gestionCollision(Serpent *serpent, Pomme pommes[]) { int CollisionAvecSerpent() {
if (collisionAvecPomme(*serpent, pommes[0])) { for (int i = 1; i < serpent.longueur; i++) {
serpent->longueur++; if (serpent.corps[0].x == serpent.corps[i].x && serpent.corps[0].y == serpent.corps[i].y) {
serpent->corps = realloc(serpent->corps, sizeof(Segment) * serpent->longueur); perdu = -1; // Le serpent a perdu
genererPommes(pommes); return 1;
}
}
return 0;
} }
if (collisionAvecSerpent(*serpent) || collisionAvecBordures(*serpent)) { int CollisionAvecBordures() {
FermerGraphique(); if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE ||
exit(EXIT_SUCCESS); serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) {
perdu = -1; // Le serpent a perdu
return 1;
} }
return 0;
} }
void deplacerSerpent(Serpent *serpent, int *direction) { void DeplacerSerpent(int* direction) {
int i; couleur couleurFond = CouleurParComposante(0, 0, 0);
couleur c; couleur couleurSerpent = CouleurParComposante(255, 255, 0);
couleur v; couleur couleurTerrain = CouleurParComposante(111, 255, 94);
couleur s;
c = CouleurParNom("black");
s = CouleurParNom("yellow");
v = CouleurParNom("light green");
for (i = 0; i < serpent->longueur; i++) { for (int i = 0; i < serpent.longueur; i++) {
ChoisirCouleurDessin(v); 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);
} }
for (i = serpent->longueur - 1; i > 0; i--) {
serpent->corps[i] = serpent->corps[i - 1]; for (int i = serpent.longueur - 1; i > 0; i--) {
serpent.corps[i] = serpent.corps[i - 1];
} }
if (ToucheEnAttente()) { if (ToucheEnAttente()) {
@ -133,57 +192,107 @@ void deplacerSerpent(Serpent *serpent, int *direction) {
} }
} }
/* Déplace la tête en fonction de la direction */
if (*direction == 1) { if (*direction == 1) {
serpent->corps[0].x += TAILLE_CASE; serpent.corps[0].x += TAILLE_CASE;
} else if (*direction == 2) { } else if (*direction == 2) {
serpent->corps[0].x -= TAILLE_CASE; serpent.corps[0].x -= TAILLE_CASE;
} else if (*direction == 3) { } else if (*direction == 3) {
serpent->corps[0].y -= TAILLE_CASE; serpent.corps[0].y -= TAILLE_CASE;
} else if (*direction == 4) { } else if (*direction == 4) {
serpent->corps[0].y += TAILLE_CASE; serpent.corps[0].y += TAILLE_CASE;
} }
for (i = 0; i < serpent->longueur; i++) { for (int i = 0; i < serpent.longueur; i++) {
ChoisirCouleurDessin(s); 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(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 main() {
int touche, go_on = 1, direction = 1; int direction = 1;
Serpent serpent; unsigned long suivant = Microsecondes() + CYCLE;
Pomme pommes[NOMBRE_POMMES]; int temps[2] = {0, 0}, seconde_actuel, old_seconde;
couleur c; int jeuEnPause = 0;
couleur v; int perdu = 0;
couleur s;
srand(time(NULL));
InitialiserJeu();
Graphique(); Graphique();
InitialiserGraphique(); EffacerEcran(CouleurParComposante(0, 0, 0));
CreerFenetre(10, 10, 1200, 820); AffichageBasique();
c = CouleurParNom("black"); GenererPommes();
s = CouleurParNom("yellow"); AfficherSerpent();
v = CouleurParNom("green"); AfficherScore();
EffacerEcran(c);
for (int i = 0; i < serpent.longueur; i++) {
serpent.corps[i].x = LARGEUR / 2;
serpent.corps[i].y = HAUTEUR / 2;
}
serpent.longueur = 10;
serpent.corps = malloc(sizeof(Segment) * serpent.longueur);
EcranJeu();
genererPommes(pommes);
afficherSerpent(serpent);
while (go_on) { while (perdu != -1) {
gestionCollision(&serpent, pommes); if (!jeuEnPause) {
deplacerSerpent(&serpent, &direction); 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;
}
}
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) {
jeuEnPause = 0;
}
}
}
} }
Touche();
FermerGraphique(); FermerGraphique();
LibererMemoire();
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }

282
snake.c
View File

@ -2,76 +2,176 @@
#include <graph.h> #include <graph.h>
#include <time.h> #include <time.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h>
#define HAUTEUR 40 #define HAUTEUR 40
#define LARGEUR 60 #define LARGEUR 60
#define TAILLE_CASE 20 #define TAILLE_CASE 19
#define ESPACE_HAUT 35
#define ESPACE_BAS 85
#define NOMBRE_POMMES 5 #define NOMBRE_POMMES 5
#define CYCLE 100000L #define CYCLE 100000L
typedef struct { typedef struct {
int x; int x;
int y; int y;
} Segment; } Position;
typedef struct {
Position* corps;
int longueur;
} Serpent;
typedef struct {
Position* positions;
int nombre;
} Pommes;
Serpent serpent;
Pommes pommes;
int score = 0; // Ajout de la variable score
int perdu = 0; // Variable pour indiquer si le serpent a perdu
void Attendre(unsigned int millisecondes) { void Attendre(unsigned int millisecondes) {
usleep(millisecondes * 1000); usleep(millisecondes * 1000);
} }
/* Fonction pour concevoir le graphique */ 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() { void Graphique() {
InitialiserGraphique(); InitialiserGraphique();
CreerFenetre(10, 10, 1240, 940); CreerFenetre(1, 1, 1240, 940);
EcrireTexte(500, 400, "Le jeu va commencer !", 2); EcrireTexte(500, 400, "Le jeu va commencer !", 2);
sleep(1); 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(10, 10, TAILLE_CASE * LARGEUR, TAILLE_CASE * LARGEUR); RemplirRectangle(0, 0, 1175, 775);
} }
/* Fonction permettant d'afficher le serpent */ void AfficherScore() {
void afficherSerpent(Segment serpent[], int taille) { char scoreText[20]; // Correction de la taille du tableau
int i; 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); couleur couleurSerpent = CouleurParComposante(255, 255, 0);
ChoisirCouleurDessin(couleurSerpent); ChoisirCouleurDessin(couleurSerpent);
for (i = 0; i < 10; i++) {
serpent[i].x = LARGEUR / 2 + i * TAILLE_CASE; for (int i = 0; i < serpent.longueur; i++) {
serpent[i].y = HAUTEUR / 2; RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
}
for (i = 0; i < taille; i++) {
RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
} }
} }
void genererPommes(Segment pommes[]) { void GenererPommes() {
for (int i = 0; i < NOMBRE_POMMES; i++) { couleur couleurPommes = CouleurParComposante(255, 0, 0);
pommes[i].x = rand() % LARGEUR * TAILLE_CASE; pommes.positions = malloc(sizeof(Position) * pommes.nombre);
pommes[i].y = rand() % HAUTEUR * TAILLE_CASE;
ChoisirCouleurDessin(CouleurParComposante(255, 0, 0)); for (int i = 0; i < pommes.nombre; i++) {
RemplirRectangle(pommes[i].x * TAILLE_CASE, pommes[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); 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 deplacerSerpent(int longueurSerpent, Segment serpent[], int *direction) { void GenererNouvellePomme() {
int i; couleur couleurPommes = CouleurParComposante(255, 0, 0);
couleur c; int i = rand() % pommes.nombre; // Utilisation d'une position aléatoire
couleur v; pommes.positions[i].x = rand() % LARGEUR;
couleur s; pommes.positions[i].y = rand() % HAUTEUR;
c = CouleurParComposante(0,0,0); ChoisirCouleurDessin(couleurPommes);
s = CouleurParComposante(255,255,0); RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
v = CouleurParComposante(111,255,94);
for (i = 0; i < longueurSerpent; i++) {
ChoisirCouleurDessin(v);
RemplirRectangle(serpent[i].x, serpent[i].y, TAILLE_CASE, TAILLE_CASE);
} }
for (i = longueurSerpent - 1; i > 0; i--) {
serpent[i] = serpent[i - 1]; 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()) { if (ToucheEnAttente()) {
@ -91,50 +191,108 @@ void deplacerSerpent(int longueurSerpent, Segment serpent[], int *direction) {
break; break;
} }
} }
/* Déplace la tête en fonction de la direction */
if (*direction == 1) { if (*direction == 1) {
serpent[0].x += TAILLE_CASE; serpent.corps[0].x += TAILLE_CASE;
} else if (*direction == 2) { } else if (*direction == 2) {
serpent[0].x -= TAILLE_CASE; serpent.corps[0].x -= TAILLE_CASE;
} else if (*direction == 3) { } else if (*direction == 3) {
serpent[0].y -= TAILLE_CASE; serpent.corps[0].y -= TAILLE_CASE;
} else if (*direction == 4) { } else if (*direction == 4) {
serpent[0].y += TAILLE_CASE; serpent.corps[0].y += TAILLE_CASE;
} }
for (i = 0; i < longueurSerpent; i++) { for (int i = 0; i < serpent.longueur; i++) {
ChoisirCouleurDessin(s); ChoisirCouleurDessin(couleurSerpent);
RemplirRectangle(serpent[i].x, serpent[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(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 main() {
int touche, perdu = 0, i, j, x = 0, direction = 1, longueurSerpent = 10; int direction = 1;
Segment serpent[LARGEUR * HAUTEUR]; unsigned long suivant = Microsecondes() + CYCLE;
Segment pommes[NOMBRE_POMMES]; int temps[2] = {0, 0}, seconde_actuel, old_seconde;
couleur c = CouleurParComposante(0,0,0); int jeuEnPause = 0;
couleur v = CouleurParComposante(111,255,94); int perdu = 0;
couleur s = CouleurParComposante(255,255,0);
srand(time(NULL));
/* Position initiale du serpent au milieu du tableau */
serpent[0].x = LARGEUR / 2 * TAILLE_CASE;
serpent[0].y = HAUTEUR / 2 * TAILLE_CASE;
InitialiserJeu();
Graphique(); Graphique();
EffacerEcran(c); EffacerEcran(CouleurParComposante(0, 0, 0));
AffichageBasique(); AffichageBasique();
genererPommes(pommes); GenererPommes();
afficherSerpent(serpent, longueurSerpent); AfficherSerpent();
AfficherScore();
while (perdu != -1) { while (perdu != -1) {
deplacerSerpent(longueurSerpent, serpent, &direction); 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;
}
}
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) {
jeuEnPause = 0;
}
}
}
} }
Touche();
FermerGraphique(); FermerGraphique();
LibererMemoire();
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }

203
test.c
View File

@ -1,203 +0,0 @@
#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;
}