ajout de la fonction de manger des pommes

This commit is contained in:
Yann KERAUDREN 2023-12-17 04:09:38 +01:00
parent ec6bc5987d
commit cc1e72bee9
8 changed files with 165 additions and 97 deletions

@ -19,11 +19,11 @@ void deplacement (struct adresse* pointeur, unsigned char* sens) {
int** plateau = pointeur -> plateau;
signed char* tete = pointeur -> tete;
unsigned char* tete = pointeur -> tete;
unsigned int** corps_serpent = pointeur -> corps_serpent;
int** corps_serpent = pointeur -> corps_serpent;
unsigned int* indice_queue = pointeur -> indice_queue;
unsigned short* indice_queue = pointeur -> indice_queue;
int touche;
@ -47,20 +47,24 @@ void deplacement (struct adresse* pointeur, unsigned char* sens) {
if (touche == XK_Left) {
plateau[tete[0]][tete[1]] = 0;
plateau[tete[0]][tete[1] - 1] = 1;
plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
tete[1] = tete[1] - 1;
ChoisirCouleurDessin(yellow);
RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
*sens = GAUCHE;
supp_queue(pointeur);
supp_queue(pointeur);
plateau[tete[0]][tete[1]] = 1;
return;
@ -70,19 +74,21 @@ void deplacement (struct adresse* pointeur, unsigned char* sens) {
plateau[tete[0]][tete[1]] = 0;
plateau[tete[0]][tete[1] + 1] = 1;
plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
tete[1] = tete[1] + 1;
ChoisirCouleurDessin(yellow);
RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
*sens = DROITE;
supp_queue(pointeur);
supp_queue(pointeur);
plateau[tete[0]][tete[1]] = 1;
return;
}
@ -91,19 +97,21 @@ void deplacement (struct adresse* pointeur, unsigned char* sens) {
plateau[tete[0]][tete[1]] = 0;
plateau[tete[0] - 1][tete[1]] = 1;
plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
tete[0] = tete[0] - 1;
ChoisirCouleurDessin(yellow);
RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
*sens = HAUT;
supp_queue(pointeur);
supp_queue(pointeur);
plateau[tete[0]][tete[1]] = 1;
return;
}
@ -112,19 +120,21 @@ void deplacement (struct adresse* pointeur, unsigned char* sens) {
plateau[tete[0]][tete[1]] = 0;
plateau[tete[0] + 1][tete[1]] = 1;
plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
tete[0] = tete[0] + 1;
ChoisirCouleurDessin(yellow);
RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
*sens = BAS;
supp_queue(pointeur);
supp_queue(pointeur);
plateau[tete[0]][tete[1]] = 1;
return;
@ -137,71 +147,76 @@ void deplacement (struct adresse* pointeur, unsigned char* sens) {
if ( *sens == BAS) {
plateau[tete[0] + 1][tete[1]] = 1;
plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
tete[0] = tete[0] + 1;
ChoisirCouleurDessin(yellow);
RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
supp_queue(pointeur);
plateau[tete[0]][tete[1]] = 1;
}
if ( *sens == HAUT) {
plateau[tete[0] - 1][tete[1]] = 1;
plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
tete[0] = tete[0] - 1;
ChoisirCouleurDessin(yellow);
RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
supp_queue(pointeur);
plateau[tete[0]][tete[1]] = 1;
}
if ( *sens == DROITE) {
plateau[tete[0]][tete[1] + 1] = 1;
plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
tete[1] = tete[1] + 1;
ChoisirCouleurDessin(yellow);
RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
supp_queue(pointeur);
plateau[tete[0]][tete[1]] = 1;
}
if ( *sens == GAUCHE) {
plateau[tete[0]][tete[1] - 1] = 1;
plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
tete[1] = tete[1] - 1;
ChoisirCouleurDessin(yellow);
RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
supp_queue(pointeur);
plateau[tete[0]][tete[1]] = 1;
}
/* mise à jour de la position de queue dans le plateau et sur le plateau */
supp_queue( pointeur);
}
}

@ -6,15 +6,16 @@
#include <stdlib.h>
#include <graph.h>
#include "plateau_init.h"
#include "fenetre.h"
int start (struct adresse* pointeur) {
void start (struct adresse* pointeur) {
couleur green, grey, yellow, red, black, white;
int** tableau = pointeur -> plateau;
int** plateau = pointeur -> plateau;
int i, j;
@ -86,14 +87,14 @@ int start (struct adresse* pointeur) {
for (i = 0; i < LIGNES; i++) {
for (j = 0; j < COLONNES; j++) {
if ( tableau[i][j] == 0) {
if ( plateau[i][j] == 0) {
green = CouleurParComposante(50,205,50);
ChoisirCouleurDessin(green);
RemplirRectangle(20*(j+1),20*(i+1),20,20);
}
if ( tableau[i][j] == 1) {
if ( plateau[i][j] == 1) {
yellow = CouleurParComposante(255,255,0);
ChoisirCouleurDessin(yellow);
@ -101,7 +102,7 @@ int start (struct adresse* pointeur) {
}
if ( tableau[i][j] == 2) {
if ( plateau[i][j] == 2) {
red = CouleurParComposante(255,0,0);
ChoisirCouleurDessin(red);
@ -114,23 +115,6 @@ int start (struct adresse* pointeur) {
/* déallocation du tableau */
for ( i = 0; i < LIGNES; i++) {
free(tableau[i]);
}
free(tableau);
return EXIT_SUCCESS;
}

Binary file not shown.

@ -1,9 +1,11 @@
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include "fenetre.h"
#include "plateau_init.h"
#include "deplacement.h"
#include "score_init.h"
#define CYCLE 200000L
@ -19,7 +21,7 @@ int main(void) {
int i = 0;
unsigned int* indice_queue = pointeur -> indice_queue;
unsigned short* indice_queue = pointeur -> indice_queue;
unsigned char* sens = NULL;
@ -51,22 +53,19 @@ int main(void) {
start(pointeur);
compteur = score_init();
while ( jeu = 1) {
while ( jeu == 1) {
if (Microsecondes() > suivant) {
printf("%u %u\n", pointeur -> corps_serpent[*indice_queue][0], pointeur -> corps_serpent[*indice_queue][1]);
printf("%d %d\n", pointeur -> corps_serpent[*indice_queue][0], pointeur -> corps_serpent[*indice_queue][1]);
printf("[%hhu %hhu]\n", tete[0], tete[1]);
printf("[%hhu %hhu]\n", tete[0], tete[1]);
deplacement(pointeur, sens);
@ -74,11 +73,10 @@ int main(void) {
suivant = Microsecondes() + CYCLE;
}
}
}
}
@ -86,12 +84,13 @@ int main(void) {
for ( i = 0; i < LIGNES; i++) {
free(pointeur->plateau[i]);
free(pointeur -> plateau[i]);
}
free(pointeur -> plateau);
for ( i =0; i < TAILLE_SERPENT; i++) {
for ( i = 0; i < TAILLE_SERPENT; i++) {
free(pointeur -> corps_serpent[i]);
@ -100,9 +99,6 @@ int main(void) {
free(pointeur -> corps_serpent);
free(pointeur -> plateau);
free(pointeur -> tete);
free(pointeur -> indice_queue);
@ -120,9 +116,8 @@ int main(void) {
Touche();
FermerGraphique();
Touche();
FermerGraphique();
return EXIT_SUCCESS;
return EXIT_SUCCESS;
}

@ -15,10 +15,10 @@ struct adresse* plateau_init(void) {
int ligne_pomme, colonne_pomme, i;
unsigned char* tete = NULL;
unsigned int* indice_queue = NULL;
unsigned int* taille_serpent = NULL;
unsigned short* indice_queue = NULL;
unsigned short* taille_serpent = NULL;
unsigned int** corps_serpent = NULL;
int** corps_serpent = NULL;
int** plateau = NULL;
@ -42,9 +42,9 @@ struct adresse* plateau_init(void) {
/* allocation du tableau tete et queue */
tete = malloc(2*sizeof(unsigned char));
tete = malloc(2 * sizeof(unsigned char));
indice_queue = malloc(sizeof(unsigned int));
indice_queue = malloc(sizeof(unsigned short));
@ -65,11 +65,11 @@ struct adresse* plateau_init(void) {
/* allocation du corps du serpent */
corps_serpent = malloc(TAILLE_SERPENT * sizeof(unsigned int*));
corps_serpent = malloc(TAILLE_SERPENT * sizeof(int*));
for ( i = 0; i < TAILLE_SERPENT; i++) {
corps_serpent[i] = malloc( 2 * sizeof(unsigned int));
corps_serpent[i] = malloc( 2 * sizeof(int));
}
@ -77,7 +77,7 @@ struct adresse* plateau_init(void) {
/* allocation de la taille du serpent */
taille_serpent = malloc(sizeof(unsigned int));
taille_serpent = malloc(sizeof(unsigned short));
/* positionnement du serpent et marquage de la tete et la queue */

@ -15,10 +15,10 @@
struct adresse {
int** plateau;
unsigned int** corps_serpent;
unsigned int* taille_serpent;
int** corps_serpent;
unsigned short* taille_serpent;
unsigned char* tete;
unsigned int* indice_queue;
unsigned short* indice_queue;
};

@ -9,15 +9,18 @@
short int* score_init(void) {
short int* compteur = NULL;
compteur = malloc(sizeof(short int));
*compteur = 0;
char a[20];
char a[20];
sprintf(a, "%d", *compteur);
compteur = malloc(sizeof(short int));
*compteur = 0;
EcrireTexte(1250, 600, a, 2);
return compteur;
sprintf(a, "%d", *compteur);
EcrireTexte(1250, 600, a, 2);
return compteur;
}

@ -6,6 +6,7 @@
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include <time.h>
#include "supp_queue.h"
@ -14,29 +15,99 @@
void supp_queue( struct adresse* pointeur ) {
unsigned int** corps_serpent = pointeur -> corps_serpent;
int** corps_serpent = pointeur -> corps_serpent;
unsigned int* taille_serpent = pointeur -> taille_serpent;
int** plateau = pointeur -> plateau;
unsigned short* taille_serpent = pointeur -> taille_serpent;
unsigned char* tete = pointeur -> tete;
unsigned int* indice_queue = pointeur -> indice_queue;
unsigned short* indice_queue = pointeur -> indice_queue;
int ligne_pomme, colonne_pomme;
couleur green;
couleur green, red;
srand(time(NULL));
green = CouleurParComposante(50,205,50);
ChoisirCouleurDessin(green);
RemplirRectangle(20*(corps_serpent[*indice_queue][1]+1),20*(corps_serpent[*indice_queue][0]+1),20,20);
corps_serpent[*indice_queue][0] = tete[0];
corps_serpent[*indice_queue][1] = tete[1];
/* teste si le serpent mange une pomme */
if (plateau[tete[0]][tete[1]] == 2 ) {
/* augmentation de la taille du serpent */
*taille_serpent = *taille_serpent + 1;
corps_serpent = realloc( corps_serpent, *taille_serpent * sizeof(int*));
pointeur -> corps_serpent = corps_serpent;
corps_serpent[*taille_serpent - 1] = malloc( 2 * sizeof(int));
corps_serpent[*taille_serpent - 1][0] = tete[0];
corps_serpent[*taille_serpent - 1][1] = tete[1];
/* apparition de la nouvelle pomme */
ligne_pomme = rand() % 40;
colonne_pomme = rand() % 60;
/* teste pour ne pas faire apparaître la pomme sur une case déjà occupée */
while (plateau[ligne_pomme][colonne_pomme] == 2 || plateau[ligne_pomme][colonne_pomme] == 1) {
ligne_pomme = rand() % 40;
colonne_pomme = rand() % 60;
}
plateau[ligne_pomme][colonne_pomme] = 2;
red = CouleurParComposante(255,0,0);
ChoisirCouleurDessin(red);
RemplirRectangle(20*(colonne_pomme + 1),20*(ligne_pomme + 1),20,20);
}
else {
*indice_queue = *indice_queue + 1;
green = CouleurParComposante(50,205,50);
ChoisirCouleurDessin(green);
RemplirRectangle(20*(corps_serpent[*indice_queue][1]+1),20*(corps_serpent[*indice_queue][0]+1),20,20);
corps_serpent[*indice_queue][0] = tete[0];
corps_serpent[*indice_queue][1] = tete[1];
*indice_queue = *indice_queue + 1;
}
if ( *indice_queue == *taille_serpent ) {