avancement sur les déplacement du serpent

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

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 */
-    
-    
- 
 }
 
 

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

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

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; 
   
 
   

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

snake/supp_queue.c

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

snake/supp_queue.h

@@ -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 */
+
+
+  

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

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 */
-
-
-