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

Merge branch 'master' of dwarves.iut-fbleau.fr:mommeja/SAE11_2023

Browse Source 
deleted:    #jeu.c#
	new file:   Makefile
	deleted:    final.c
	deleted:    graphique.c
	deleted:    "id\303\251e.c"
	deleted:    jeu.c
	deleted:    jeu.c~
	modified:   serpent.c
	deleted:    serpent.c~
	deleted:    snake.c
	deleted:    test.c
	deleted:    .#jeu.c
This commit is contained in:
Tom MOMMEJA 2023-12-12 14:17:19 +01:00
commit 14e4b083ce
11 changed files with 272 additions and 1169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

191
#jeu.c#
View File

@ -1,191 +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 50
/* 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, 1175, 775);
}
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) {
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, int *aMangerPomme) {
int i;
/* Vérifie la collision avec la pomme */
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;
*aMangerPomme = 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 = RIGHT; // Ajout de la direction initiale
int aMangerPomme = 0;
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, &aMangerPomme);
serpent(snake, taille);
}
}
/* Génération de nouvelles pommes si le serpent en a mangé une */
if (aMangerPomme) {
aMangerPomme = 0; // Réinitialise la variable après avoir généré les pommes
genererPommes(pommes);
perdu = 0; /* enlever ça pour faire des obstacle*/
}
if (perdu == -1) {
printf("Vous avez perdu ! Collision avec la paroi.\n");
FermerGraphique();
*score =0;
}
return EXIT_SUCCESS;
}

14
Makefile Normal file
View File

@ -0,0 +1,14 @@
CC = gcc
CFLAGS = -Wall -Wextra -I.
LIBS = -lgraph
all: serpent
serpent: main.o serpent.o
$(CC) $(CFLAGS) $^ -o $@ $(LIBS)
%.o: %.c
$(CC) $(CFLAGS) -c $< -o $@
clean:
rm -f *.o serpent

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

158
idée.c
View File

@ -1,158 +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[100]; // 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, enum direction dir) {
// 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
switch (dir) {
case UP:
snake->queue[0].y--;
break;
case DOWN:
snake->queue[0].y++;
break;
case LEFT:
snake->queue[0].x--;
break;
case RIGHT:
snake->queue[0].x++;
break;
}
}
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.queue[0].x = NOMBRE_CASES_X / 2;
snake.queue[0].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;
enum direction direction = RIGHT; // Direction initiale
while (1) {
EffacerEcran(0);
deplacerSnake(&snake, direction);
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;
}
if (ToucheEnAttente()) {
int touche = Touche();
if (touche == 65 && direction != DOWN) { // 65 correspond à la touche '↑'
direction = UP;
} else if (touche == 66 && direction != UP) { // 66 correspond à la touche '↓'
direction = DOWN;
} else if (touche == 68 && direction != RIGHT) { // 68 correspond à la touche '←'
direction = LEFT;
} else if (touche == 67 && direction != LEFT) { // 67 correspond à la touche '→'
direction = RIGHT;
}
}
}
}
int main(void) {
Snake snake;
Fruit fruit;
enum direction{RIGHT,UP,LEFT,DOWN};
Position positionCase;
positionCase.x = 5;
positionCase.y = 5;
couleur couleurCase = CouleurParComposante(255, 255, 255);
initialiserGraphique();
dessinerCase(positionCase, couleurCase);
afficherSnake(&Snake);
afficherFruit(&Fruit);
deplacerSnake(&Snake, direction);
jeuSnake();
return EXIT_SUCCESS;
}

192
jeu.c
View File

@ -1,192 +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 50
/* 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, 1236, 936);
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, 1175, 775);
}
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) {
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, int *aMangerPomme) {
/* 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;
*aMangerPomme = 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 = RIGHT; // Ajout de la direction initiale
int aMangerPomme = 0;
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, &aMangerPomme);
serpent(snake, taille);
}
/* Génération de nouvelles pommes si le serpent en a mangé une */
if (aMangerPomme) {
aMangerPomme = 0; // Réinitialise la variable après avoir généré les pommes
perdu = 0; /* enlever ça pour faire des obstacle*/
}
}
if (perdu == -1) {
printf("Vous avez perdu ! Collision avec la paroi.\n");
FermerGraphique();
}
return EXIT_SUCCESS;
}

0
jeu.c~
View File

386
serpent.c
View File

@ -1,187 +1,317 @@
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h>
#include <graph.h> #include <graph.h>
#include <time.h> #include <time.h>
#include <stdio.h>
#include <unistd.h>
#define HAUTEUR 40 #define HAUTEUR 40
#define LARGEUR 60 #define LARGEUR 60
#define TAILLE_CASE 19
#define NOMBRE_POMMES 5
#define NOMBRE_OBSTACLES 20
#define CYCLE 100000L #define CYCLE 100000L
#define TAILLE_CASE 20
/* 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 { typedef struct {
int posx, posy; int x;
} SnakePoint; int y;
} Position;
/* Fonction pour concevoir le graphique */ typedef struct {
void graphique() { Position* corps;
int longueur;
} Serpent;
typedef struct {
Position* positions;
int nombre;
} Pommes;
typedef struct {
Position* positions;
int nombre;
} Obstacles;
pomme[i-1].position=pomme[i].position
Serpent serpent;
Pommes pommes;
Obstacles obstacles;
int score = 0;
int perdu = 0;
void Attendre(unsigned int millisecondes) {
usleep(millisecondes * 1000);
}
void InitialiserJeu() {
serpent.longueur = 10;
serpent.corps = malloc(sizeof(Position) * serpent.longueur);
pommes.nombre = NOMBRE_POMMES;
obstacles.nombre = NOMBRE_OBSTACLES;
srand(time(NULL));
serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE;
serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE;
perdu = 0;
// Initialisation des obstacles
obstacles.positions = malloc(sizeof(Position) * obstacles.nombre);
for (int i = 0; i < obstacles.nombre; i++) {
obstacles.positions[i].x = rand() % LARGEUR;
obstacles.positions[i].y = rand() % HAUTEUR;
}
}
void GenererObstacles() {
couleur couleurObstacle = CouleurParComposante(0, 0, 255);
for (int i = 0; i < obstacles.nombre; i++) {
ChoisirCouleurDessin(couleurObstacle);
RemplirRectangle(obstacles.positions[i].x * TAILLE_CASE, obstacles.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
}
}
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, 1200, 820); RemplirRectangle(0, 0, 1140, 760);
}
void AfficherScore() {
char scoreText[20];
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);
free(obstacles.positions);
} }
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);
ChoisirCouleurDessin(CouleurParComposante(0, 0, 0)); ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
RemplirRectangle(20, 870, 70, 40); RemplirRectangle(20, 870, 70, 40);
ChoisirCouleurDessin(CouleurParComposante(255, 255, 255)); ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
EcrireTexte(20, 900, temps, 2); EcrireTexte(20, 900, temps, 2);
} }
/* Fonction pour afficher le serpent */ void AfficherSerpent() {
void serpent(SnakePoint *snake, int taille) { couleur couleurSerpent = CouleurParComposante(255, 255, 0);
for (int i = 0; i < taille; i++) { ChoisirCouleurDessin(couleurSerpent);
couleur s = CouleurParComposante(255, 255, 0);
ChoisirCouleurDessin(s); for (int i = 0; i < serpent.longueur; i++) {
RemplirRectangle(snake[i].posx * TAILLE_CASE, snake[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
} }
} }
/* Fonction pour générer les pommes */ void GenererPommes() {
void genererPommes(SnakePoint *pommes) { couleur couleurPommes = CouleurParComposante(255, 0, 0);
for (int i = 0; i < 5; i++) { pommes.positions = malloc(sizeof(Position) * pommes.nombre);
pommes[i].posx = rand() % LARGEUR;
pommes[i].posy = rand() % HAUTEUR; for (int i = 0; i < pommes.nombre; i++) {
couleur p = CouleurParComposante(255, 0, 0); pommes.positions[i].x = rand() % LARGEUR;
ChoisirCouleurDessin(p); pommes.positions[i].y = rand() % HAUTEUR;
RemplirRectangle(pommes[i].posx * TAILLE_CASE, pommes[i].posy * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE); ChoisirCouleurDessin(couleurPommes);
RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
} }
} }
/* Fonction pour gérer le mouvement de la tête du serpent */ void GenererNouvellePomme() {
void mouvementTete(SnakePoint *snake, int *dir) { couleur couleurPommes = CouleurParComposante(255, 0, 0);
/* Déplace la tête en fonction de la direction */ int i = rand() % pommes.nombre;
if (ToucheEnAttente()) { pommes.positions[i].x = rand() % LARGEUR;
int touche = Touche(); pommes.positions[i].y = rand() % HAUTEUR;
switch (touche) { ChoisirCouleurDessin(couleurPommes);
case XK_Left: RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
*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 */ int CollisionAvecPomme() {
if (*dir == LEFT) { for (int i = 0; i < pommes.nombre; i++) {
snake[0].posx -= 1; if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE &&
} else if (*dir == RIGHT) { serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE &&
snake[0].posx += 1; serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE &&
} else if (*dir == UP) { serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) {
snake[0].posy -= 1; GenererNouvellePomme();
} else if (*dir == DOWN) { score = score + 5;
snake[0].posy += 1; AfficherScore();
return 1;
} }
} }
return 0;
} }
/* Fonction pour gérer le mouvement du corps du serpent */ int CollisionAvecObstacle() {
void mouvementCorps(SnakePoint *snake, int taille) { for (int i = 0; i < obstacles.nombre; i++) {
/* Déplace le corps du serpent en suivant la tête */ if (serpent.corps[0].x == obstacles.positions[i].x * TAILLE_CASE &&
for (int i = taille - 1; i > 0; i--) { serpent.corps[0].y == obstacles.positions[i].y * TAILLE_CASE) {
snake[i] = snake[i - 1]; perdu = -1; // Le serpent a perdu
} return 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 */
} }
} }
return 0;
}
/* Vérifie la collision avec la paroi intérieure du rectangle */ int CollisionAvecSerpent() {
if (snake[0].posx <= 0 || snake[0].posx >= LARGEUR - 1 || snake[0].posy <= 0 || snake[0].posy >= HAUTEUR - 1) { for (int i = 1; i < serpent.longueur; i++) {
return -1; // Collision avec la paroi if (serpent.corps[0].x == serpent.corps[i].x && serpent.corps[0].y == serpent.corps[i].y) {
perdu = -1;
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;
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);
} }
return 0; // Pas de collision for (int i = serpent.longueur - 1; i > 0; i--) {
serpent.corps[i] = serpent.corps[i - 1];
}
if (*direction == 1) {
serpent.corps[0].x += TAILLE_CASE;
} else if (*direction == 2) {
serpent.corps[0].x -= TAILLE_CASE;
} else if (*direction == 3) {
serpent.corps[0].y -= TAILLE_CASE;
} else if (*direction == 4) {
serpent.corps[0].y += TAILLE_CASE;
}
for (int i = 0; i < serpent.longueur; i++) {
ChoisirCouleurDessin(couleurSerpent);
RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
}
Attendre(100);
}
int GestionCollision(int perdu) {
int loose = perdu;
if (CollisionAvecPomme()) {
serpent.longueur = serpent.longueur + 2;
serpent.corps = realloc(serpent.corps, sizeof(Position) * serpent.longueur);
loose = 1;
}
if (CollisionAvecObstacle() || CollisionAvecSerpent() || CollisionAvecBordures()) {
loose = -1;
}
return loose;
} }
int main() { int main() {
/* Initialisation du jeu */ int direction = 1;
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();
genererPommes(pommes);
unsigned long suivant = Microsecondes() + CYCLE; unsigned long suivant = Microsecondes() + CYCLE;
int perdu = 0;
int temps[2] = {0, 0}, seconde_actuel, old_seconde; int temps[2] = {0, 0}, seconde_actuel, old_seconde;
int jeuEnPause = 0;
int perdu = 0;
while (!perdu) { InitialiserJeu();
/* Calcul du temps */ Graphique();
if (Microsecondes() > suivant) { EffacerEcran(CouleurParComposante(0, 0, 0));
suivant = Microsecondes() + CYCLE; AffichageBasique();
seconde_actuel = (suivant / 1000000) % 10; GenererPommes();
if (seconde_actuel != old_seconde) { GenererObstacles(); // Ajout de la génération des obstacles
old_seconde = seconde_actuel; AfficherSerpent();
if ((temps[1] + 1) == 60) { AfficherScore();
temps[0]++;
temps[1] = 0; while (perdu != -1) {
} else { if (!jeuEnPause) {
temps[1]++; 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]);
} }
/* Affichage du temps */
AfficheTemps(temps[0], temps[1]);
} }
if (ToucheEnAttente()) {
/* Déplacement du serpent */ int touche = Touche();
mouvementTete(snake, &dir); switch (touche) {
mouvementCorps(snake, taille); case XK_Right:
perdu = gererCollisions(snake, &taille, pommes); direction = 1;
serpent(snake, taille); break;
case XK_Left:
/* Génération de nouvelles pommes si le serpent en a mangé une */ direction = 2;
if (perdu == 1) { break;
genererPommes(pommes); case XK_Up:
direction = 3;
break;
case XK_Down:
direction = 4;
break;
case XK_space:
jeuEnPause = 1;
break;
case XK_Escape:
return EXIT_FAILURE;
}
}
DeplacerSerpent(&direction);
perdu = GestionCollision(perdu);
} else {
if (ToucheEnAttente()) {
int touche = Touche();
if (touche == XK_space) {
if (touche == XK_Escape) {
return EXIT_FAILURE;
}
jeuEnPause = 0;
}
} }
} }
} }
if (perdu == -1) {
printf("Vous avez perdu ! Collision avec la paroi.\n");
} else {
printf("Vous avez perdu ! Collision avec une pomme.\n");
}
FermerGraphique(); FermerGraphique();
LibererMemoire();
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }

0
serpent.c~
View File

185
snake.c
View File

@ -1,185 +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
/* 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;
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 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 */
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 */
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;
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 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);
}
}
}
}
FermerGraphique();
return EXIT_SUCCESS;
}

187
test.c
View File

@ -1,187 +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
/* 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;
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 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;
}
/* 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;
/* Le serpent a mangé une pomme 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 dir;
srand(time(NULL));
/* Position initiale du serpent au milieu du tableau */
snake[0].posx = LARGEUR / 2;
snake[0].posy = HAUTEUR / 2;
graphique();
AffichageBasique();
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 if(perdu == 1){
}
FermerGraphique();
return EXIT_SUCCESS;
}