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

avancement sur les déplacement du serpent

Browse Source
This commit is contained in:
Yann KERAUDREN 2023-12-14 01:07:57 +01:00
parent d3e69dec40
commit fd0c4a36a8
11 changed files with 256 additions and 134 deletions

5
snake/Makefile

@ -11,8 +11,9 @@ OFILES = plateau_init.o \
deplacement.o \
ajout_score.o \
score_init.o \
supp_queue.o \
main.o
CC = gcc
@ -26,6 +27,8 @@ fenetre.o : fenetre.h plateau_init.h
deplacement.o : deplacement.h
supp_queue.o : supp_queue.h
ajout_score.o : ajout_score.h
score_init.o : score_init.h

187
snake/deplacement.c

@ -7,7 +7,7 @@
#include <stdio.h>
#include <graph.h>
#include "plateau_init.h"
#include "update_queue.h"
#include "supp_queue.h"
#include "deplacement.h"
@ -21,7 +21,11 @@ void deplacement (struct adresse* pointeur, unsigned char* sens) {
unsigned char* tete = pointeur -> tete;
unsigned char* queue = pointeur -> queue;
unsigned int** corps_serpent = pointeur -> corps_serpent;
unsigned int* indice_queue = pointeur -> indice_queue;
int touche;
couleur green, yellow;
@ -31,59 +35,6 @@ void deplacement (struct adresse* pointeur, unsigned char* sens) {
printf("%d %d", queue[0], queue[1]);
if ( *sens == BAS) {
plateau[tete[0] + 1][tete[1]] = 1;
plateau[queue[0]][queue[1]] = 0;
tete[0] = tete[0] + 1;
ChoisirCouleurDessin(yellow);
RemplirRectangle(20*(tete[1] + 1),20*(tete[0] +1 ),20,20);
ChoisirCouleurDessin(green);
RemplirRectangle(20*(queue[1] +1 ),20*(queue[0] +1 ),20,20);
queue[0] = queue[0] + 1;
}
if ( *sens == HAUT) {
plateau[tete[0] - 1][tete[1]] = 1;
plateau[queue[0]][queue[1]] = 0;
tete[0] = tete[0] -1;
}
if ( *sens == DROITE) {
plateau[tete[0]][tete[1] + 1] = 1;
plateau[queue[0]][queue[1]] = 0;
tete[1] = tete[1] + 1;
}
if ( *sens == GAUCHE) {
plateau[tete[0]][tete[1] - 1] = 1;
plateau[queue[0]][queue[1]] = 0;
tete[1] = tete[1] - 1;
}
@ -91,71 +42,167 @@ void deplacement (struct adresse* pointeur, unsigned char* sens) {
if (ToucheEnAttente() == 1) {
if (Touche() == XK_Left) {
touche = Touche();
if (touche == XK_Left) {
plateau[tete[0]][tete[1]] = 0;
plateau[tete[0]][tete[1] - 1] = 1;
plateau[queue[0]][queue[1]] = 0;
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);
return;
}
if (Touche() == XK_Right) {
if (touche == XK_Right) {
plateau[tete[0]][tete[1]] = 0;
plateau[tete[0]][tete[1] + 1] = 1;
plateau[queue[0]][queue[1]] = 0;
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);
return;
}
if (Touche() == XK_Up) {
if (touche == XK_Up) {
plateau[tete[0]][tete[1]] = 0;
plateau[tete[0] - 1][tete[1]] = 1;
plateau[queue[0]][queue[1]] = 0;
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);
return;
}
if (Touche() == XK_Down) {
if (touche == XK_Down) {
plateau[tete[0]][tete[1]] = 0;
plateau[tete[0] + 1][tete[1]] = 1;
plateau[queue[0]][queue[1]] = 0;
plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
tete[0] = tete[0] + 1;
*sens = DROITE;
ChoisirCouleurDessin(yellow);
RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
*sens = BAS;
supp_queue(pointeur);
return;
}
}
else {
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);
}
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);
}
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);
}
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);
}
/* mise à jour de la position de queue dans le plateau et sur le plateau */
supp_queue( pointeur);
}
/* mise à jour de la position de queue dans le plateau */
}

2
snake/fenetre.c

@ -97,7 +97,7 @@ int start (struct adresse* pointeur) {
yellow = CouleurParComposante(255,255,0);
ChoisirCouleurDessin(yellow);
RemplirRectangle(20*(j+1),20*(i+1),20,20);
RemplirRectangle(20*(j+1),20*(i+1),20,40);
}

BIN
snake/lancement Executable file

Binary file not shown.

29
snake/main.c

@ -6,7 +6,7 @@
#include "deplacement.h"
#define CYCLE 1000000L
#define CYCLE 200000L
int main(void) {
@ -16,9 +16,10 @@ int main(void) {
short int* compteur = NULL;
int i;
int i = 0;
unsigned int* indice_queue = pointeur -> indice_queue;
unsigned char* sens = NULL;
@ -27,6 +28,7 @@ int main(void) {
unsigned long suivant;
sens = malloc(sizeof(unsigned char));
*sens = 2;
@ -59,11 +61,15 @@ int main(void) {
if (Microsecondes() > suivant) {
printf("%u %u\n", pointeur -> corps_serpent[*indice_queue][0], pointeur -> corps_serpent[*indice_queue][1]);
deplacement(pointeur, sens);
suivant = Microsecondes() + CYCLE;
}
@ -79,13 +85,26 @@ int main(void) {
}
for ( i =0; i < TAILLE_SERPENT; i++) {
free(pointeur -> corps_serpent[i]);
}
free(pointeur -> corps_serpent);
free(pointeur -> plateau);
free(pointeur -> tete);
free(pointeur -> queue);
free(pointeur -> indice_queue);
free(sens);
free(sens);
free(pointeur -> taille_serpent);
free(pointeur);

51
snake/plateau_init.c

@ -14,10 +14,12 @@ struct adresse* plateau_init(void) {
int ligne_pomme, colonne_pomme, i;
unsigned char* tete = NULL;
unsigned char* queue = NULL;
unsigned int* indice_queue = NULL;
unsigned int* taille_serpent = NULL;
unsigned int** corps_serpent = NULL;
int** plateau = NULL;
@ -27,19 +29,28 @@ struct adresse* plateau_init(void) {
srand(time(NULL));
/* allocation du pointeur */
pointeur = malloc(sizeof( struct adresse));
/* allocation du tableau tete et queue */
tete = malloc(2*sizeof(unsigned char));
queue = malloc(2*sizeof(unsigned char));
indice_queue = malloc(sizeof(unsigned int));
/* allocation du tableau dans le tas */
/* allocation du plateau dans le tas */
plateau = calloc(LIGNES, sizeof(int*));
@ -49,9 +60,26 @@ struct adresse* plateau_init(void) {
}
/* allocation du corps du serpent */
corps_serpent = malloc(TAILLE_SERPENT * sizeof(unsigned int*));
for ( i = 0; i < TAILLE_SERPENT; i++) {
corps_serpent[i] = malloc( 2 * sizeof(unsigned int));
}
/* allocation de la taille du serpent */
taille_serpent = malloc(sizeof(unsigned int));
/* positionnement du serpent et marquage de la tete et la queue */
tete[0] = ((LIGNES/2)+(TAILLE_SERPENT/2)-1);
@ -59,13 +87,14 @@ struct adresse* plateau_init(void) {
queue[0] = ((LIGNES/2)-(TAILLE_SERPENT/2));
queue[1] = COLONNES/2;
for (i = 0; i < TAILLE_SERPENT ; i++) {
plateau[((LIGNES/2)-5)+i][COLONNES/2] = 1;
corps_serpent[i][0] = ((LIGNES/2)-5) + i;
corps_serpent[i][1] = COLONNES/2;
}
@ -96,11 +125,15 @@ struct adresse* plateau_init(void) {
}
*taille_serpent = TAILLE_SERPENT;
*indice_queue = 0;
pointeur -> plateau = plateau;
pointeur -> tete = tete;
pointeur -> queue = queue;
pointeur -> indice_queue = indice_queue;
pointeur -> corps_serpent = corps_serpent;
pointeur -> taille_serpent = taille_serpent;

4
snake/plateau_init.h

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

51
snake/supp_queue.c Normal file

@ -0,0 +1,51 @@
/* Fonction qui mets à jour la position de la queue en fonction des déplacement du serpent
Written by Yann KERAUDREN and Titouan LERICHE */
#include <stdlib.h>
#include <stdio.h>
#include <graph.h>
#include "supp_queue.h"
void supp_queue( struct adresse* pointeur ) {
unsigned int** corps_serpent = pointeur -> corps_serpent;
unsigned int* taille_serpent = pointeur -> taille_serpent;
unsigned char* tete = pointeur -> tete;
unsigned int* indice_queue = pointeur -> indice_queue;
couleur green;
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 ) {
*indice_queue = 0;
}
}

14
snake/supp_queue.h Normal file

@ -0,0 +1,14 @@
/* fichier d'en-tête du fichier source supp_queue.c */
#ifndef SUPP_QUEUE_H
#define SUPP_QUEUE_H
#include "plateau_init.h"
void supp_queue(struct adresse* pointeur) ;
#endif /* SUPP_QUEUE_H */

35
snake/update_queue.c

@ -1,35 +0,0 @@
/* Fonction qui mets à jour la position de la queue en fonction des déplacement du serpent
Written by Yann KERAUDREN and Titouan LERICHE */
#include <stdlib.h>
#include <stdio.h>
void maj_queue(int* queue, int** p) {
if ( p[queue[0] +1 ][queue[1]] == 1 ) {
queue[0] = queue[0] +1 ;
}
if ( p[queue[0] - 1][queue[1]] == 1 ) {
queue[0] = queue[0] -1;
}
if ( p [queue[0]][queue[1]+1] == 1) {
queue[1] = queue [1] +1;
}
if ( p [queue[0]][queue[1]-1] == 1) {
queue[1] = queue[1] -1;
}
}

12
snake/update_queue.h

@ -1,12 +0,0 @@
/* fichier d'en-tête du fichier source test_queue.c */
#ifndef UPDATE_QUEUE_H
#define UPDATE_QUEUE_H
int test_queue(int* queue, int** p) ;
#endif /* UPDATE_QUEUE_H */