ajout de la fonction de manger des pommes

snake/deplacement.c

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

snake/fenetre.c

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

snake/main.c

@@ -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();
+   return EXIT_SUCCESS;
-  FermerGraphique();
-
-  return EXIT_SUCCESS;
 }

snake/plateau_init.c

@@ -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 short* indice_queue = NULL;
-  unsigned int* taille_serpent = 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 */

snake/plateau_init.h

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

snake/score_init.c

@@ -9,15 +9,18 @@
 short int* score_init(void) {
     
     short int* compteur = NULL;
-	compteur = malloc(sizeof(short int));
+    char a[20];
-	*compteur = 0;
 
-	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;
 }
 

snake/supp_queue.c

@@ -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, red;
-  couleur green;
+
+
+  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];
+  /* teste si le serpent mange une pomme */
-  corps_serpent[*indice_queue][1] = tete[1];
 
+  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 )  {