ajout de la délimitation du terrain de jeu et coupure du jeu si le serpent se rentre dedans

snake/deplacement.c

@@ -14,7 +14,7 @@
 
 
 
-void deplacement (struct adresse* pointeur, unsigned char* sens)  {
+unsigned char deplacement (struct adresse* pointeur, unsigned char* sens)  {
 
 
   int** plateau = pointeur -> plateau;
@@ -45,138 +45,307 @@ void deplacement (struct adresse* pointeur, unsigned char* sens)  {
     touche = Touche();
 
     if (touche == XK_Left) {
+
+
       
-      plateau[tete[0]][tete[1]] = 0;
+      /* test de dépassement des limites du plateau de jeu */
+      if ( tete[1] == 0)  {
+
+	return 0;
+
+      }
+
+
+      /* modificaton du plateau de jeu et affichage de la tête */ 
+      else{
       
 
-      plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
+	plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
 
-      tete[1] = tete[1] - 1;
+	tete[1] = tete[1] - 1;
 
 
-      ChoisirCouleurDessin(yellow);
+
-      RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
+	/* test si le serpent se rentre dedans */
+	if (plateau[tete[0]][tete[1]] == 1)  {
+
+	  return 0;
 
 
-      *sens = GAUCHE;
+	}else{
 
-      supp_queue(pointeur);
 
-      plateau[tete[0]][tete[1]] = 1;
+	  ChoisirCouleurDessin(yellow);
+	  RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
+
+
+	  *sens = GAUCHE;
+
+	  supp_queue(pointeur);
+
+	  plateau[tete[0]][tete[1]] = 1;
 
       
 
-      return;
+	  return 1;
+
+	}
 	
+      }
+
     }
 
+
+
+
+
+    
+
     if (touche == XK_Right)  {
 
-      plateau[tete[0]][tete[1]] = 0;
+
+      
+      /* test de dépassement des limites du plateau de jeu */
+      if (tete[1] == COLONNES - 1)  {
+
+	return 0;
+
+      }
 
 
-      plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
 
-      tete[1] = tete[1] + 1;
+      /* modificaton du plateau de jeu et affichage de la tête */ 
+      else{
 
 
-      ChoisirCouleurDessin(yellow);
+	plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
-      RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
+
+	tete[1] = tete[1] + 1;
 
 
-      *sens = DROITE;
+	
+	/* test si le serpent se rentre dedans */
+	if ( plateau[tete[0]][tete[1]] == 1)  {
 
-      supp_queue(pointeur);
+	  return 0;
 
-      plateau[tete[0]][tete[1]] = 1;
 
-      return; 
+	}else{
+
+
+	  ChoisirCouleurDessin(yellow);
+	  RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
+
+
+	  *sens = DROITE;
+
+	  supp_queue(pointeur);
+
+	  plateau[tete[0]][tete[1]] = 1;
+
+	  return 1;
+
+	}
+      }
+
     }
 
+    
+
     if (touche == XK_Up)  {
 
-      plateau[tete[0]][tete[1]] = 0;
+      
+      
+      /* test de dépassement des limites du plateau de jeu */
+      if (tete[0] == 0)  {
+
+	return 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);
+      /* modificaton du plateau de jeu et affichage de la tête */ 
+      else{ 
 
 
-      *sens = HAUT;
+	plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
 
-      supp_queue(pointeur);
+	tete[0] = tete[0] - 1;
+	
 
-      plateau[tete[0]][tete[1]] = 1;
+	/* test si le serpent se rentre dedans */
+	if (plateau[tete[0]][tete[1]] == 1)  {
 
-      return; 
+	  return 0;
+
+
+	}else{
+
+
+	  ChoisirCouleurDessin(yellow);
+	  RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
+
+
+	  *sens = HAUT;
+
+	  supp_queue(pointeur);
+
+	  plateau[tete[0]][tete[1]] = 1;
+
+	  return 1;
+
+	}
+      }
     }
 
+
+    
+
     if (touche == XK_Down)  {
 
-      plateau[tete[0]][tete[1]] = 0;
+      
+
+      /* test de dépassement des limites du plateau de jeu */
+      if (tete[0] == LIGNES - 1)  {
+
+	return 0;
+
+      }
 
 
-      plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
 
-      tete[0] = tete[0] + 1;
+      /* modificaton du plateau de jeu et affichage de la tête */ 
+      else{
 
 
-      ChoisirCouleurDessin(yellow);
+	plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
-      RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
+
+	tete[0] = tete[0] + 1;
 
 
-      *sens = BAS;
+	
+	/* test si le serpent se rentre dedans */
+	if (plateau[tete[0]][tete[1]] == 1) {
 
-      supp_queue(pointeur);
+	  return 0;
+	
 
-      plateau[tete[0]][tete[1]] = 1;
+	  
 
-      return; 
+	}else{
+
+
+	  ChoisirCouleurDessin(yellow);
+	  RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
+
+
+	  *sens = BAS;
+
+	  supp_queue(pointeur);
+
+	  plateau[tete[0]][tete[1]] = 1;
+
+	  return 1;
+
+	}
+
+      }
 
     }
 
  
   }
 
+
+    
+
   else {
 
     if ( *sens == BAS)  {
 
 
-      plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
+      /* test de dépassement des limites du plateau de jeu */
+      if ( tete[0] == LIGNES - 1 )  {
 
-      tete[0] = tete[0] + 1;
 
-      
+	return 0;
-
-      ChoisirCouleurDessin(yellow);
-      RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
-
-      
-      supp_queue(pointeur);
-      plateau[tete[0]][tete[1]] = 1;
 	
+      }
+
+
+      /* modificaton du plateau de jeu et affichage de la tête */ 
+      else {
+	
+	
+
+	plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
+      
+	tete[0] = tete[0] + 1;
+
+	/* test si le serpent se rentre dedans */
+	if (plateau[tete[0]][tete[1]] == 1) {
+
+	  return 0;
+	
+	}else{
+
+      
+
+	  ChoisirCouleurDessin(yellow);
+	  RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
+
+      
+	  supp_queue(pointeur);
+	  plateau[tete[0]][tete[1]] = 1;
+
+	  return 1;
+
+	}
+	
+      }
     }
 
     if ( *sens == HAUT)  {
 
 
-      plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
+      /* test de dépassement des limites du plateau de jeu */
+      if ( tete[0] == 0)  {
+
+	return 0;
+
+      }
+
+
+      /* modificaton du plateau de jeu et affichage de la tête */ 
+      else{
+
+
+	plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
       
-      tete[0] = tete[0] - 1;
+	tete[0] = tete[0] - 1;
+
+	/* test si le serpent se rentre dedans */
+	if (plateau[tete[0]][tete[1]] == 1) {
+
+	  return 0;
+	
+	}else{
 
      
-      ChoisirCouleurDessin(yellow);
+	  ChoisirCouleurDessin(yellow);
-      RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
+	  RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
-
+	
       
-      supp_queue(pointeur);
+	  supp_queue(pointeur);
-      plateau[tete[0]][tete[1]] = 1;
+	  plateau[tete[0]][tete[1]] = 1;
+
+	  return 1;
+
+	}
+      }
       
     }
 
@@ -185,37 +354,89 @@ void deplacement (struct adresse* pointeur, unsigned char* sens)  {
     if ( *sens == DROITE)  {
 
 
-      plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
+      /* test de dépassement des limites du plateau de jeu */
+      if ( tete[1] == COLONNES - 1)  {
 
-      tete[1] = tete[1] + 1;
+	return 0;
+
+      }
 
 
-      ChoisirCouleurDessin(yellow);
+
-      RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
+      /* modificaton du plateau de jeu et affichage de la tête */ 
+      else{
+      
+	
+	plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
+      
+	tete[1] = tete[1] + 1;
+
+
+	/* test si le serpent se rentre dedans */
+	if (plateau[tete[0]][tete[1]] == 1) {
+
+	  return 0;
+	
+	}else{
 
       
-      supp_queue(pointeur);
+	  ChoisirCouleurDessin(yellow);
-      plateau[tete[0]][tete[1]] = 1;
+	  RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
+      
+      
+	  supp_queue(pointeur);
+	  plateau[tete[0]][tete[1]] = 1;
+
+	  return 1;
+
+	}
+      }
       
     }
-
+    
     if ( *sens == GAUCHE)  {
 
 
-      plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
+      /* test de dépassement des limites du plateau de jeu */
-    
+      if (tete[1] == 0) {
-      tete[1] = tete[1] - 1;
 
-      
+	return 0;
 
-      ChoisirCouleurDessin(yellow);
+      }
-      RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
+
-    
+
+
+
+      /* modificaton du plateau de jeu et affichage de la tête */ 
+      else {
       
-      supp_queue(pointeur);
+      
-      plateau[tete[0]][tete[1]] = 1;
+	plateau[corps_serpent[*indice_queue][0]][corps_serpent[*indice_queue][1]] = 0;
+      
+	tete[1] = tete[1] - 1;
+
+
+	/* test si le serpent se rentre dedans */
+	if (plateau[tete[0]][tete[1]] == 1) {
+
+	  return 0;
+	
+	}else{
+      
+      
+	  ChoisirCouleurDessin(yellow);
+	  RemplirRectangle(20*(tete[1]+1),20*(tete[0]+1),20,20);
+	
+	
+	  supp_queue(pointeur);
+	  plateau[tete[0]][tete[1]] = 1;
+	
+	  return 1;
+
+	}
+      }
     }
-
+    
   }
 	
 }

snake/deplacement.h

@@ -9,6 +9,6 @@
 #define GAUCHE 3
 #include "plateau_init.h"
 
-void deplacement (struct adresse* pointeur, unsigned char* sens);
+unsigned char deplacement (struct adresse* pointeur, unsigned char* sens);
 
 #endif /* DEPLACEMENT_H */

snake/main.c

@@ -16,9 +16,11 @@ int main(void)  {
 
   struct adresse* pointeur =  plateau_init();
 
+  int** plateau = pointeur -> plateau;
+
   short int* compteur = NULL;
 
-  int i = 0;
+  int i = 0, j;
   
 
   unsigned short* indice_queue = pointeur -> indice_queue;
@@ -58,20 +60,23 @@ int main(void)  {
   compteur = score_init();
 
   
-  while ( jeu == 1)  {
+  while (jeu ==  1)  {
 
     if (Microsecondes() > suivant) {
 
-      printf("%d %d\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);
+      jeu = deplacement(pointeur, sens);
 
       suivant = Microsecondes() + CYCLE;
 
+     
+
 
       
     }

snake/supp_queue.c

@@ -1,4 +1,4 @@
-/* Fonction qui mets à jour la position de la queue en fonction des déplacement du serpent
+/* Fonction qui efface la queue du serpent lorsqu'il se déplace et augmente la taille du serpent lorsqu'il mange une pomme
 
    Written by Yann KERAUDREN and Titouan LERICHE */
 
@@ -26,7 +26,7 @@ void supp_queue( struct adresse* pointeur )  {
   unsigned short* indice_queue = pointeur -> indice_queue; 
 
 
-  int ligne_pomme, colonne_pomme;
+  int ligne_pomme, colonne_pomme, i;
 
   
   
@@ -35,9 +35,7 @@ void supp_queue( struct adresse* pointeur )  {
 
   srand(time(NULL));
 
-
+	 
-
-  
 
   /* teste si le serpent mange une pomme */
 
@@ -53,9 +51,23 @@ void supp_queue( struct adresse* pointeur )  {
 
     corps_serpent[*taille_serpent - 1] = malloc( 2 * sizeof(int));
 
+    /* printf("%d %d \n", tete[0], tete[1]);
+
+
+    /* problème de mise en place de la tête du serpent au bonne endroit dans le corps */
+
     corps_serpent[*taille_serpent - 1][0] = tete[0];
     corps_serpent[*taille_serpent - 1][1] = tete[1];
 
+    /*for (i = 0; i < *taille_serpent; i++)  {
+   
+  
+
+      printf("[%d %d]  ", corps_serpent[i][0], corps_serpent[i][1]);
+
+    }
+
+    printf("\n");*/