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-09 15:34:02 +01:00
parent c757b24214
commit a5c4d48b2d
11 changed files with 678 additions and 817 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

168
essai.c Normal file
View File

@ -0,0 +1,168 @@
#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~ Normal file
View File

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

68
final.c
View File

@ -1,68 +0,0 @@
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include <time.h>
#include <unistd.h>
#define HAUTEUR 40
#define LARGEUR 60
#define CYCLE 100000L
#define SEGMENT 10
/* Enumeration des différentes directions possibles */
enum dir { UP = 2, DOWN = 3, LEFT = 0, RIGHT = 1 };
/* Structure pour stocker les coordonnées des segments du serpent */
typedef struct {
int x,y;
}SnakePoint;
typedef struct {
int posx, posy;
} PommePoint;
/* Fonction pour afficher le serpent */
void serpent(SnakePoint *snake, int taille) {
for (int i = 0; i < taille; i++) {
couleur s = CouleurParComposante(255, 255, 0);
ChoisirCouleurDessin(s);
RemplirRectangle(snake[i].x * SEGMENT, snake[i].y * SEGMENT, SEGMENT, SEGMENT);
}
}
void pomme(SnakePoint *pommes){
/* Vérifie si le serpent a mangé la pomme à partir des coordonnées et génère une nouvelle pomme */
for (int i = 0; i < 5; i++) {
pommes[i].x = rand() % LARGEUR;
pommes[i].y = rand() % HAUTEUR;
couleur p = CouleurParComposante(255,0, 0);
ChoisirCouleurDessin(s);
RemplirRectangle(pomme[i].x, pomme[i].y);
}
void MouvenmentTete(SnakePoint *){
for (int i = *taille - 1; i > 0; i--) {
snake[i] = snake[i - 1];
}
/* Déplace la tête en fonction de la direction */
if (*dir == LEFT) {
snake[0].posx = (snake[0].posx - 1 + LARGEUR) % LARGEUR;
} else if (*dir == RIGHT) {
snake[0].posx = (snake[0].posx + 1) % LARGEUR;
} else if (*dir == UP) {
snake[0].posy = (snake[0].posy - 1 + HAUTEUR) % HAUTEUR;
} else if (*dir == DOWN) {
snake[0].posy = (snake[0].posy + 1) % HAUTEUR;
}

60
graphique.c
View File

@ -1,60 +0,0 @@
#include<stdlib.h>
#include<stdio.h>
#include<graph.h>
#include<time.h>
#define H 40
#define L 60
#define CYCLE 100000L;
void graphique(int n){
InitialiserGraphique();
CreerFenetre(1700,950,1700,950);
couleur c, b;
b=CouleurParComposante(0,0,0);
ChoisirCouleurDessin(b);
RemplirRectangle(0,0,1750,950);
c=CouleurParComposante(111,255,94);
ChoisirCouleurDessin(c);
RemplirRectangle(100,100,1500,750);
Touche();
FermerGraphique();
};
enum Direction {Stop=0,Droite=XK_Right,Gauche=XK_Left,Haut=XK_Up,Bas=XK_Down};
enum Direction direction;
void snake(){
couleur s;
s=CouleurParNom("yellow");
ChoisirCouleurDessin(s);
RemplirRectangle(200,200);
}
int main(void){
int n;
graphique();
int tab[H][L];
int i,j,posx=100,posy=100,n=0;
double suivant;
suivant=Microseconde()+CYCLE;
for(i=0;i<H;i++){
for(j=0;j<L;j++){
tab[i][j]=0;
}
}
while(1){
if (Microsecondes()>suivant){
n++;
graphique();
suivant= Microseconde()+CYCLE;
}
}
return EXIT_SUCCESS;
}

132
idée.c
View File

@ -1,132 +0,0 @@
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include <time.h>
#define LARGEUR_FENETRE 1080
#define HAUTEUR_FENETRE 1080
#define TAILLE_CASE 5
#define NOMBRE_CASES_X (LARGEUR_FENETRE / TAILLE_CASE)
#define NOMBRE_CASES_Y (HAUTEUR_FENETRE / TAILLE_CASE)
enum direction{UP,DOWN,RIGHT,LEFT};
typedef struct {
int x, y;
} Position;
typedef struct {
Position position;
int taille;
Position queue[10]; // Augmentez la taille si nécessaire
} Snake;
typedef struct {
Position position;
} Fruit;
void initialiserGraphique() {
InitialiserGraphique();
CreerFenetre(LARGEUR_FENETRE, HAUTEUR_FENETRE, LARGEUR_FENETRE, HAUTEUR_FENETRE);
}
void dessinerCase(Position position, couleur c) {
ChoisirCouleurDessin(c);
RemplirRectangle(position.x * TAILLE_CASE, position.y * TAILLE_CASE, (position.x + 1) * TAILLE_CASE, (position.y + 1) * TAILLE_CASE);
}
void afficherSnake(Snake *snake) {
couleur couleurSnake = CouleurParComposante(0, 255, 0); // Vert
for (int i = 0; i < snake->taille; i++) {
dessinerCase(snake->queue[i], couleurSnake);
}
}
void afficherFruit(Fruit *fruit) {
couleur couleurFruit = CouleurParComposante(255, 0, 0); // Rouge
dessinerCase(fruit->position, couleurFruit);
}
void deplacerSnake(Snake *snake) {
// Déplacer la queue
for (int i = snake->taille - 1; i > 0; i--) {
snake->queue[i] = snake->queue[i - 1];
}
// Déplacer la tête
if (ToucheEnAttente()) {
int touche = Touche();
if (touche == UP) {
snake->queue[0].y--;
} else if (touche == DOWN) {
snake->queue[0].y++;
} else if (touche == LEFT) {
snake->queue[0].x--;
} else if (touche == RIGHT) {
snake->queue[0].x++;
}
}
int collisionAvecFruit(Snake *snake, Fruit *fruit) {
return snake->queue[0].x == fruit->position.x && snake->queue[0].y == fruit->position.y;
}
int collisionAvecMur(Snake *snake) {
return snake->queue[0].x < 0 || snake->queue[0].x >= NOMBRE_CASES_X ||
snake->queue[0].y < 0 || snake->queue[0].y >= NOMBRE_CASES_Y;
}
int collisionAvecQueue(Snake *snake) {
for (int i = 1; i < snake->taille; i++) {
if (snake->queue[0].x == snake->queue[i].x && snake->queue[0].y == snake->queue[i].y) {
return 1;
}
}
}
return 0;
}
*/
void jeuSnake() {
initialiserGraphique();
Snake snake;
snake.position.x = NOMBRE_CASES_X / 2;
snake.position.y = NOMBRE_CASES_Y / 2;
snake.taille = 1;
Fruit fruit;
srand(time(NULL));
fruit.position.x = rand() % NOMBRE_CASES_X;
fruit.position.y = rand() % NOMBRE_CASES_Y;
while (1) {
EffacerEcran(0);
deplacerSnake(&snake);
afficherSnake(&snake);
afficherFruit(&fruit);
if (collisionAvecFruit(&snake, &fruit)) {
// Manger le fruit
snake.taille++;
fruit.position.x = rand() % NOMBRE_CASES_X;
fruit.position.y = rand() % NOMBRE_CASES_Y;
}
if (collisionAvecMur(&snake) || collisionAvecQueue(&snake)) {
FermerGraphique();
printf("Game Over!\n");
break;
}
}
}
int main(void) {
while(1){
initialiserGraphique();
dessinerCase();
jeuSnake();
afficherSnake();
}
return EXIT_SUCCESS;
}

189
jeu.c
View File

@ -1,189 +0,0 @@
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include <time.h>
#define HAUTEUR 40
#define LARGEUR 60
#define CYCLE 100000L
#define TAILLE_CASE 20
#define SCORE_TO_WIN 5
/* Enumeration des différentes directions possibles */
enum Direction { UP = 2, DOWN = 3, LEFT = 0, RIGHT = 1 };
/* Structure pour stocker les coordonnées des segments du serpent */
typedef struct {
int posx, posy;
} SnakePoint;
/* 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, 1200, 820);
}
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);
}
/* Fonction pour afficher le serpent */
void serpent(SnakePoint *snake, int taille) {
for (int i = 0; i < taille; i++) {
couleur s = CouleurParComposante(255, 255, 0);
ChoisirCouleurDessin(s);
RemplirRectangle(snake[i].posx * TAILLE_CASE, snake[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
}
}
/* Fonction pour générer les pommes */
void genererPommes(SnakePoint *pommes) {
for (int i = 0; i < 5; i++) {
pommes[i].posx = rand() % (LARGEUR - 2) + 1;
pommes[i].posy = rand() % (HAUTEUR - 2) + 1;
couleur p = CouleurParComposante(255, 0, 0);
ChoisirCouleurDessin(p);
RemplirRectangle(pommes[i].posx * TAILLE_CASE, pommes[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
}
}
/* Fonction pour gérer le mouvement de la tête du serpent */
void mouvementTete(SnakePoint *snake, int *taille, int *score, int *dir) {
/* Déplace la tête en fonction de la direction */
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;
}
/* Déplace la tête en fonction de la direction */
if (*dir == LEFT) {
snake[0].posx -= 1;
} else if (*dir == RIGHT) {
snake[0].posx += 1;
} else if (*dir == UP) {
snake[0].posy -= 1;
} else if (*dir == DOWN) {
snake[0].posy += 1;
}
}
}
/* Fonction pour gérer le mouvement du corps du serpent */
void mouvementCorps(SnakePoint *snake, int taille) {
/* Déplace le corps du serpent en suivant la tête */
for (int i = taille - 1; i > 0; i--) {
snake[i] = snake[i - 1];
}
}
/* Fonction pour gérer les collisions */
int gererCollisions(SnakePoint *snake, int *taille, int *score, SnakePoint *pommes) {
/* Vérifie la collision avec la pomme */
for (int i = 0; i < 5; i++) {
if (snake[0].posx == pommes[i].posx && snake[0].posy == pommes[i].posy) {
/* Augmente le score et génère une nouvelle pomme */
*score += 5;
pommes[i].posx = rand() % (LARGEUR - 2) + 1;
pommes[i].posy = rand() % (HAUTEUR - 2) + 1;
return 1; /* Le serpent a mangé une pomme */
}
}
/* Vérifie la collision avec la paroi intérieure du rectangle */
if (snake[0].posx <= 0 || snake[0].posx >= LARGEUR - 1 || snake[0].posy <= 0 || snake[0].posy >= HAUTEUR - 1) {
return -1; /* Collision avec la paroi */
}
return 0; /* Pas de collision */
}
int main() {
/* Initialisation du jeu */
graphique();
SnakePoint snake[LARGEUR * HAUTEUR];
SnakePoint pommes[5];
int taille = 1;
int score = 0;
int dir;
srand(time(NULL));
/* Position initiale du serpent au milieu du tableau */
snake[0].posx = LARGEUR / 2;
snake[0].posy = HAUTEUR / 2;
graphique();
AffichageBasique();
genererPommes(pommes);
unsigned long suivant = Microsecondes() + CYCLE;
int perdu = 0;
int temps[2] = {0, 0}, seconde_actuel, old_seconde;
while (!perdu) {
/* 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]);
}
/* Déplacement du serpent */
mouvementTete(snake, &taille, &score, &dir);
mouvementCorps(snake, taille);
perdu = gererCollisions(snake, &taille, &score, pommes);
serpent(snake, taille);
/* Génération de nouvelles pommes si le serpent en a mangé une */
if (perdu == 1) {
genererPommes(pommes);
}
}
}
if (perdu == -1) {
printf("Vous avez perdu ! Collision avec la paroi.\n");
} else {
printf("Vous avez gagné avec un score de %d points ! Félicitations.\n", score);
}
FermerGraphique();
return EXIT_SUCCESS;
}

0
jeu.c~
View File

274
serpent.c
View File

@ -1,23 +1,35 @@
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include <time.h>
#include <stdio.h>
#define HAUTEUR 40
#define LARGEUR 60
#define CYCLE 100000L
#define TAILLE_CASE 20
#define NOMBRE_POMMES 5
#define CYCLE 100000L
/* Enumeration des différentes directions possibles */
enum Direction { UP = 2, DOWN = 3, LEFT = 0, RIGHT = 1 };
/* Structure pour stocker les coordonnées des segments du serpent */
typedef struct {
int posx, posy;
} SnakePoint;
int x;
int y;
} Segment;
typedef struct {
int x;
int y;
} Pomme;
typedef struct {
int longueur;
Segment* corps;
} Serpent;
void Attendre(unsigned int millisecondes) {
usleep(millisecondes * 1000);
}
/* Fonction pour concevoir le graphique */
void graphique() {
void Graphique() {
InitialiserGraphique();
CreerFenetre(10, 10, 1240, 940);
EcrireTexte(500, 400, "Le jeu va commencer !", 2);
@ -25,163 +37,153 @@ void graphique() {
EffacerEcran(CouleurParComposante(0, 0, 0));
}
void AffichageBasique() {
ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
RemplirRectangle(10, 10, 1200, 820);
}
/* Fonction permettant d'afficher le serpent */
void afficherSerpent(Serpent serpent) {
couleur couleurSerpent = CouleurParNom("yellow");
ChoisirCouleurDessin(couleurSerpent);
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);
}
/* Fonction pour afficher le serpent */
void serpent(SnakePoint *snake, int taille) {
for (int i = 0; i < taille; i++) {
couleur s = CouleurParComposante(255, 255, 0);
ChoisirCouleurDessin(s);
RemplirRectangle(snake[i].posx * TAILLE_CASE, snake[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
for (int i = 0; i < serpent.longueur; i++) {
RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
}
}
/* Fonction pour générer les pommes */
void genererPommes(SnakePoint *pommes) {
for (int i = 0; i < 5; i++) {
pommes[i].posx = rand() % LARGEUR;
pommes[i].posy = rand() % HAUTEUR;
couleur p = CouleurParComposante(255, 0, 0);
ChoisirCouleurDessin(p);
RemplirRectangle(pommes[i].posx * TAILLE_CASE, pommes[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
void genererPommes(Pomme 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 gérer le mouvement de la tête du serpent */
void mouvementTete(SnakePoint *snake, int *dir) {
/* Déplace la tête en fonction de la direction */
/* Fonction initialisant la fenetre de jeux en vert */
void EcranJeu() {
couleur v = CouleurParNom("light green");
for (int i = 2; i < 42; i++) {
for (int j = 5; j < 65; j++) {
ChoisirCouleurDessin(v);
RemplirRectangle(j * TAILLE_CASE, i * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
}
}
}
int collisionAvecPomme(Serpent serpent, Pomme pomme) {
return (serpent.corps[0].x == pomme.x && serpent.corps[0].y == pomme.y);
}
int collisionAvecBordures(Serpent serpent) {
return (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE ||
serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE);
}
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;
}
void gestionCollision(Serpent *serpent, Pomme pommes[]) {
if (collisionAvecPomme(*serpent, pommes[0])) {
serpent->longueur++;
serpent->corps = realloc(serpent->corps, sizeof(Segment) * serpent->longueur);
genererPommes(pommes);
}
if (collisionAvecSerpent(*serpent) || collisionAvecBordures(*serpent)) {
FermerGraphique();
exit(EXIT_SUCCESS);
}
}
void deplacerSerpent(Serpent *serpent, int *direction) {
int i;
couleur c;
couleur v;
couleur s;
c = CouleurParNom("black");
s = CouleurParNom("yellow");
v = CouleurParNom("light green");
for (i = 0; i < serpent->longueur; i++) {
ChoisirCouleurDessin(v);
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];
}
if (ToucheEnAttente()) {
int touche = Touche();
switch (touche) {
case XK_Left:
*dir = LEFT;
break;
case XK_Right:
*dir = RIGHT;
*direction = 1;
break;
case XK_Left:
*direction = 2;
break;
case XK_Up:
*dir = UP;
*direction = 3;
break;
case XK_Down:
*dir = DOWN;
*direction = 4;
break;
}
/* Déplace la tête en fonction de la direction */
if (*dir == LEFT) {
snake[0].posx -= 1;
} else if (*dir == RIGHT) {
snake[0].posx += 1;
} else if (*dir == UP) {
snake[0].posy -= 1;
} else if (*dir == DOWN) {
snake[0].posy += 1;
}
}
}
/* Fonction pour gérer le mouvement du corps du serpent */
void mouvementCorps(SnakePoint *snake, int taille) {
/* Déplace le corps du serpent en suivant la tête */
for (int i = taille - 1; i > 0; i--) {
snake[i] = snake[i - 1];
}
}
/* Fonction pour gérer les collisions */
int gererCollisions(SnakePoint *snake, int *taille, SnakePoint *pommes) {
/* Vérifie la collision avec la pomme */
for (int i = 0; i < 5; i++) {
if (snake[0].posx == pommes[i].posx && snake[0].posy == pommes[i].posy) {
/* Augmente la taille du serpent */
*taille += 1;
pommes[i].posx = (rand() % (LARGEUR - 2)) + 1;
pommes[i].posy = (rand() % (HAUTEUR - 2)) + 1;
return 1; /* Collision avec une pomme */
}
}
/* Vérifie la collision avec la paroi intérieure du rectangle */
if (snake[0].posx <= 0 || snake[0].posx >= LARGEUR - 1 || snake[0].posy <= 0 || snake[0].posy >= HAUTEUR - 1) {
return -1; // Collision avec la paroi
/* Déplace la tête en fonction de la direction */
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;
}
return 0; // Pas de collision
for (i = 0; i < serpent->longueur; i++) {
ChoisirCouleurDessin(s);
RemplirRectangle(serpent->corps[i].x, serpent->corps[i].y, TAILLE_CASE, TAILLE_CASE);
}
Attendre(100);
}
int main() {
/* Initialisation du jeu */
graphique();
SnakePoint snake[LARGEUR * HAUTEUR];
SnakePoint pommes[5];
int taille = 1;
int dir;
int touche, go_on = 1, direction = 1;
Serpent serpent;
Pomme pommes[NOMBRE_POMMES];
couleur c;
couleur v;
couleur s;
srand(time(NULL));
/* Position initiale du serpent au milieu du tableau */
snake[0].posx = LARGEUR / 2;
snake[0].posy = HAUTEUR / 2;
graphique();
AffichageBasique();
Graphique();
InitialiserGraphique();
CreerFenetre(10, 10, 1200, 820);
c = CouleurParNom("black");
s = CouleurParNom("yellow");
v = CouleurParNom("green");
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);
unsigned long suivant = Microsecondes() + CYCLE;
int perdu = 0;
int temps[2] = {0, 0}, seconde_actuel, old_seconde;
while (!perdu) {
/* 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]);
}
/* Déplacement du serpent */
mouvementTete(snake, &dir);
mouvementCorps(snake, taille);
perdu = gererCollisions(snake, &taille, pommes);
serpent(snake, taille);
/* Génération de nouvelles pommes si le serpent en a mangé une */
if (perdu == 1) {
genererPommes(pommes);
}
}
}
if (perdu == -1) {
printf("Vous avez perdu ! Collision avec la paroi.\n");
} else {
printf("Vous avez perdu ! Collision avec une pomme.\n");
while (go_on) {
gestionCollision(&serpent, pommes);
deplacerSerpent(&serpent, &direction);
}
Touche();
FermerGraphique();
return EXIT_SUCCESS;
}

0
serpent.c~
View File

217
snake.c
View File

@ -1,23 +1,27 @@
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include <time.h>
#include <stdio.h>
#define HAUTEUR 40
#define LARGEUR 60
#define CYCLE 100000L
#define TAILLE_CASE 20
#define ESPACE_HAUT 35
#define ESPACE_BAS 85
#define NOMBRE_POMMES 5
#define CYCLE 100000L
/* Enumeration des différentes directions possibles */
enum Direction { UP = 2, DOWN = 3, LEFT = 0, RIGHT = 1 };
/* Structure pour stocker les coordonnées des segments du serpent */
typedef struct {
int posx, posy;
} SnakePoint;
int x;
int y;
} Segment;
void Attendre(unsigned int millisecondes) {
usleep(millisecondes * 1000);
}
/* Fonction pour concevoir le graphique */
void graphique() {
void Graphique() {
InitialiserGraphique();
CreerFenetre(10, 10, 1240, 940);
EcrireTexte(500, 400, "Le jeu va commencer !", 2);
@ -27,159 +31,110 @@ void graphique() {
void AffichageBasique() {
ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
RemplirRectangle(10, 10, 1200, 820);
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);
}
/* Fonction pour afficher le serpent */
void serpent(SnakePoint *snake, int taille) {
for (int i = 0; i < taille; i++) {
couleur s = CouleurParComposante(255, 255, 0);
ChoisirCouleurDessin(s);
RemplirRectangle(snake[i].posx * TAILLE_CASE, snake[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
/* Fonction permettant d'afficher le serpent */
void afficherSerpent(Segment serpent[], int taille) {
int i;
couleur couleurSerpent = CouleurParComposante(255,255,0);
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);
}
}
/* Fonction pour générer les pommes */
void genererPommes(SnakePoint *pommes) {
for (int i = 0; i < 5; i++) {
pommes[i].posx = rand() % LARGEUR;
pommes[i].posy = rand() % HAUTEUR;
couleur p = CouleurParComposante(255, 0, 0);
ChoisirCouleurDessin(p);
RemplirRectangle(pommes[i].posx * TAILLE_CASE, pommes[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
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 * TAILLE_CASE, pommes[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
}
}
/* Fonction pour gérer le mouvement de la tête du serpent */
void mouvementTete(SnakePoint *snake, int *taille, int *dir) {
/* Déplace la tête en fonction de la direction */
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_Left:
*dir = LEFT;
break;
case XK_Right:
*dir = RIGHT;
*direction = 1;
break;
case XK_Left:
*direction = 2;
break;
case XK_Up:
*dir = UP;
*direction = 3;
break;
case XK_Down:
*dir = DOWN;
*direction = 4;
break;
}
/* Déplace la tête en fonction de la direction */
if (*dir == LEFT) {
snake[0].posx -= 1;
} else if (*dir == RIGHT) {
snake[0].posx += 1;
} else if (*dir == UP) {
snake[0].posy -= 1;
} else if (*dir == DOWN) {
snake[0].posy += 1;
}
}
/* 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 le mouvement du corps du serpent */
void mouvementCorps(SnakePoint *snake, int taille) {
/* Déplace le corps du serpent en suivant la tête */
for (int i = taille - 1; i > 0; i--) {
snake[i] = snake[i - 1];
}
}
/* Fonction pour gérer les collisions */
void gererCollisions(SnakePoint *snake, int *taille, SnakePoint *pommes) {
/* Vérifie la collision avec la pomme */
for (int i = 0; i < 5; i++) {
if (snake[0].posx == pommes[i].posx && snake[0].posy == pommes[i].posy) {
/* Augmente la taille du serpent */
*taille += 1;
/* Déplace la pomme hors de l'écran (elle disparaît) */
pommes[i].posx = -1;
pommes[i].posy = -1;
}
/* Vérifie la collision avec la paroi intérieure du rectangle */
if (snake[0].posx <= 0 || snake[0].posx >= LARGEUR - 1 || snake[0].posy <= 0 || snake[0].posy >= HAUTEUR - 1) {
return -1; // Collision avec la paroi
}
return 0; // Pas de collision
}
}
int main() {
/* Initialisation du jeu */
graphique();
SnakePoint snake[LARGEUR * HAUTEUR];
SnakePoint pommes[5];
int taille = 1;
int dir;
int touche, perdu = 0, i, j, x = 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 */
snake[0].posx = LARGEUR / 2;
snake[0].posy = HAUTEUR / 2;
/* Position initiale du serpent au milieu du tableau */
serpent[0].x = LARGEUR / 2 * TAILLE_CASE;
serpent[0].y = HAUTEUR / 2 * TAILLE_CASE;
graphique();
Graphique();
EffacerEcran(c);
AffichageBasique();
genererPommes(pommes);
afficherSerpent(serpent, longueurSerpent);
unsigned long suivant = Microsecondes() + CYCLE;
int temps[2] = {0, 0}, seconde_actuel, old_seconde;
while (1) {
/* 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]);
}
/* Déplacement du serpent */
mouvementTete(snake, &taille, &dir);
mouvementCorps(snake, taille);
gererCollisions(snake, &taille, pommes);
serpent(snake, taille);
/* Génération de nouvelles pommes si le serpent en a mangé une */
for (int i = 0; i < 5; i++) {
if (pommes[i].posx == -1 && pommes[i].posy == -1) {
pommes[i].posx = rand() % LARGEUR;
pommes[i].posy = rand() % HAUTEUR;
couleur p = CouleurParComposante(255, 0, 0);
ChoisirCouleurDessin(p);
RemplirRectangle(pommes[i].posx * TAILLE_CASE, pommes[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
}
}
}
while (perdu!=-1) {
deplacerSerpent(longueurSerpent, serpent, &direction);
}
Touche();
FermerGraphique();
return EXIT_SUCCESS;
}

218
test.c
View File

@ -6,15 +6,29 @@
#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 = 0, RIGHT = 1 };
enum Direction { UP = 2, DOWN = 3, LEFT = 1, RIGHT = 2 };
/* Structure pour stocker les coordonnées des segments du serpent */
typedef struct {
int posx, posy;
} SnakePoint;
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() {
@ -27,7 +41,7 @@ void graphique() {
void AffichageBasique() {
ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
RemplirRectangle(10, 10, 1200, 820);
RemplirRectangle(10, 10, TAILLE_CASE * LARGEUR, TAILLE_CASE * LARGEUR);
}
void AfficheTemps(int minute, int seconde) {
@ -41,111 +55,126 @@ void AfficheTemps(int minute, int seconde) {
EcrireTexte(20, 900, temps, 2);
}
/* Fonction pour afficher le serpent */
void serpent(SnakePoint *snake, int taille) {
for (int i = 0; i < taille; i++) {
couleur s = CouleurParComposante(255, 255, 0);
ChoisirCouleurDessin(s);
RemplirRectangle(snake[i].posx * TAILLE_CASE, snake[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
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 pour générer les pommes */
void genererPommes(SnakePoint *pommes) {
for (int i = 0; i < 5; i++) {
pommes[i].posx = rand() % LARGEUR;
pommes[i].posy = rand() % HAUTEUR;
couleur p = CouleurParComposante(255, 0, 0);
ChoisirCouleurDessin(p);
RemplirRectangle(pommes[i].posx * TAILLE_CASE, pommes[i].posy * 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);
}
}
/* Fonction pour gérer le mouvement de la tête du serpent */
void mouvementTete(SnakePoint *snake, int *dir) {
/* Déplace la tête en fonction de la direction */
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;
}
int collisionAvecPomme(Position *pomme) {
return (serpent.corps[0].x == pomme->x && serpent.corps[0].y == pomme->y);
}
/* Déplace la tête en fonction de la direction */
if (*dir == LEFT) {
snake[0].posx -= 1;
} else if (*dir == RIGHT) {
snake[0].posx += 1;
} else if (*dir == UP) {
snake[0].posy -= 1;
} else if (*dir == DOWN) {
snake[0].posy += 1;
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;
}
/* Fonction pour gérer le mouvement du corps du serpent */
void mouvementCorps(SnakePoint *snake, int taille) {
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 = taille - 1; i > 0; i--) {
snake[i] = snake[i - 1];
}
}
/* Fonction pour gérer les collisions */
int gererCollisions(SnakePoint *snake, int *taille, SnakePoint *pommes) {
/* Vérifie la collision avec la pomme */
for (int i = 0; i < 5; i++) {
if (snake[0].posx == pommes[i].posx && snake[0].posy == pommes[i].posy) {
/* Augmente la taille du serpent */
*taille += 1;
pommes[i].posx = (rand() % (LARGEUR - 2)) + 1;
pommes[i].posy = (rand() % (HAUTEUR - 2)) + 1;
return 1;
/* Le serpent a mangé une pomme une pomme */
}
for (int i = serpent.longueur - 1; i > 0; i--) {
serpent.corps[i] = serpent.corps[i - 1];
}
/* Vérifie la collision avec la paroi intérieure du rectangle */
if (snake[0].posx <= 0 || snake[0].posx >= LARGEUR - 1 || snake[0].posy <= 0 || snake[0].posy >= HAUTEUR - 1) {
return -1; // Collision avec la paroi
/* 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;
}
return 0; // Pas de collision
/* 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();
SnakePoint snake[LARGEUR * HAUTEUR];
SnakePoint pommes[5];
int taille = 1;
int dir;
srand(time(NULL));
/* Position initiale du serpent au milieu du tableau */
snake[0].posx = LARGEUR / 2;
snake[0].posy = HAUTEUR / 2;
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 perdu = 0;
int dir = RIGHT; /* Direction initiale vers la droite */
int temps[2] = {0, 0}, seconde_actuel, old_seconde;
while (!perdu) {
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;
@ -162,26 +191,13 @@ int main() {
AfficheTemps(temps[0], temps[1]);
}
/* Déplacement du serpent */
mouvementTete(snake, &dir);
mouvementCorps(snake, taille);
perdu = gererCollisions(snake, &taille, pommes);
serpent(snake, taille);
/* Génération de nouvelles pommes si le serpent en a mangé une */
if (perdu == 1) {
genererPommes(pommes);
}
mouvementSerpent(dir);
gestionCollision();
ActualiserGraphique();
usleep(CYCLE);
}
}
if (perdu == -1) {
printf("Vous avez perdu ! Collision avec la paroi.\n");
} else if(perdu == 1){
}
FermerGraphique();
return EXIT_SUCCESS;
}