fin centipede

Cwik Pierre
1 parent 9b666644
Showing 112 changed files with 2359 additions and 268 deletions Show diff stats
projets/Centipede/centipede
projets/Centipede/progprinc.c~
projets/Centipede/progprinc.o
projets/Centipede/Makefile -> projets/projetsfile/Centipede/Makefile
projets/projetsfile/Centipede/centipede
projets/Centipede/progprinc.c -> projets/projetsfile/Centipede/progprinc.c
projets/projetsfile/Centipede/progprinc.c~
projets/projetsfile/Centipede/progprinc.o
projets/Centipede/scores.txt -> projets/projetsfile/Centipede/scores.txt
projets/Graphique/Makefile -> projets/projetsfile/Graphique/Makefile
projets/Graphique/libgraph.a -> projets/projetsfile/Graphique/libgraph.a
projets/Graphique/libgraph.c -> projets/projetsfile/Graphique/libgraph.c
projets/Graphique/libgraph.h -> projets/projetsfile/Graphique/libgraph.h
projets/Graphique/libgraph.o -> projets/projetsfile/Graphique/libgraph.o
projets/Liste/.directory -> projets/projetsfile/Liste/.directory
projets/Liste/Makefile -> projets/projetsfile/Liste/Makefile
projets/Liste/libFile.c -> projets/projetsfile/Liste/libFile.c
projets/Liste/libFile.h -> projets/projetsfile/Liste/libFile.h
projets/Liste/libFile.o -> projets/projetsfile/Liste/libFile.o
projets/Liste/libListe.a -> projets/projetsfile/Liste/libListe.a
@@ -1,224 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <libFile.h>
-#include <libgraph.h>
-#include <unistd.h>
-#include <time.h>
-#include <SDL/SDL.h>
-#define MAX_ELEMENTS 50
-
-typedef struct {
-  int x;
-  int y;
-}position;
-
-typedef struct {
-  position contenu[MAX_ELEMENTS];
-  int nombre;
-  } liste_champi;
-
-void affichage(element_t e)
-{ 
-  position *p = e;
-  printf("%d %d \n", p->x, p->y);
-}
-
-
-int main() {
-  SDL_keysym* detail;
-  srand(time(NULL));
-  char touche;
-  unsigned char bas;
-  int largeur = 1000;
-  int hauteur = 1000;
-  liste_champi muschrooms={.nombre=0};
-  liste_t listecenti={NULL,0,0};
-  int h,w,l,i,t;
-  int s=10;
-  char *titre = "Le Centipède";
-  
-  
-  int champi = chargerLutin("Lutins/millepatte_champi.bmp",0);
-  int Teted = chargerLutin("Lutins/millepatte_tete_droite.bmp",0);
-  int Teteg = chargerLutin("Lutins/millepatte_tete_gauche.bmp",0);
-  int Teteh = chargerLutin("Lutins/millepatte_tete_haut.bmp",0);
-  int Teteb = chargerLutin("Lutins/millepatte_tete_bas.bmp",0);
-  int Corpsg = chargerLutin("Lutins/millepatte_corps_gauche.bmp",0);
-  int Corpsd = chargerLutin("Lutins/millepatte_corps_droite.bmp",0);
-  int Corpsh = chargerLutin("Lutins/millepatte_corps_haut.bmp",0);
-  int Corpsb = chargerLutin("Lutins/millepatte_corps_bas.bmp",0);
-  int gameover = chargerLutin("Lutins/game_over.bmp",0);
-  
-  if(champi<0){ printf("Champi pas là\n"); exit(-1); }
-  tailleLutin(champi,&l,&h);
-  
-  
-  position *pos;
-  position poschampi;
-  position posmillepatte;
-  
-  creerSurface(largeur,hauteur,titre);
-  
-  int x = 300;
-  int y = 500;
-  
-  for(i=0; i<4; i++)
-  {
-    posmillepatte.x = (x + 50*i);
-    posmillepatte.y = y;
-    enfiler(&listecenti,&posmillepatte,sizeof(position));
-  }
-							//affichage des corpsd du centipede
-  for(i=0; i<4; i++)
-  {
-    pos = enieme(i,&listecenti);
-    afficherLutin(Corpsd,pos->x,pos->y);
-  }
-    
-  posmillepatte.x = (x+200);
-  posmillepatte.y = y;
-  enfiler(&listecenti,&posmillepatte,sizeof(position)); //affichage de la tete du Centipède
-  pos = enieme(4, &listecenti);
-  afficherLutin(Teted,pos->x,pos->y);
-  
-  for(i = 0 ; i < 20; i++)
-  {
-    rectanglePlein(i*50,0,1,1000,5);			//pose de la grille
-    rectanglePlein(0,i*50,1000,1,5);
-  }
-  
-  for(w=0;w<10;w++) {
-    poschampi.x = (rand()%20)*50;			//fixe coordonnées des champignons
-    poschampi.y = (rand()%20)*50;
-    if(poschampi.y > 570 || poschampi.y < 430) {
-    muschrooms.contenu[muschrooms.nombre++]=poschampi; }
-    else w--;
-  }
-  
-  printf("%d %d \n",l,h);
-  
-  for(w=0;w<10;w++){
-  afficherLutin(champi,(muschrooms.contenu[w].x)+1,(muschrooms.contenu[w].y)+6);
-  }//affiche les champis
-  majSurface();
-  
-  int gomme = creerLutin(0,0,50,50,0);
-  majSurface();
-    
-  
-  
-  while(1){
-    if(lireTouche(&bas,&touche,(void **)&detail) && bas==1) {
-	
-	if(detail->sym==SDLK_RIGHT) t=0;
-	if(detail->sym==SDLK_UP) t=1;
-	if(detail->sym==SDLK_LEFT) t=2;
-	if(detail->sym==SDLK_DOWN) t=3; }
- 	
-	usleep(500000);
-   
-    if((t==0 && s!=2) || s==0) {
-      printf("dans le droite\n");
-      pos = premier(&listecenti);
-      afficherLutin(gomme,pos->x,pos->y);
-      defiler(&listecenti);
-      
-      pos = dernier(&listecenti);
-      afficherLutin(gomme,pos->x,pos->y);
-      afficherLutin(Corpsd,(pos->x),pos->y);
-      posmillepatte.x = pos->x+50;
-      posmillepatte.y = pos->y;
-      if(posmillepatte.x > 1000 || posmillepatte.y > 1000 || posmillepatte.x < 0 || posmillepatte.y < 0){
-	afficherLutin(gameover,400,400);
-	majSurface();
-	sleep(5);
-	fermerSurface();
-	}
-      enfiler(&listecenti,&posmillepatte,sizeof(posmillepatte));
-      afficherLutin(Teted,posmillepatte.x,posmillepatte.y);
-     majSurface();
-	s=0;
-    }
-    
-    if((t==1 && s!=3) || s==1) {
-      printf("dans le haut\n");
-      pos = premier(&listecenti);
-      afficherLutin(gomme,pos->x,pos->y);
-      defiler(&listecenti);
-      
-      pos = dernier(&listecenti);
-      afficherLutin(gomme,pos->x,pos->y);
-      afficherLutin(Corpsh,(pos->x),pos->y);
-      posmillepatte.x = pos->x;
-      posmillepatte.y = pos->y-50;
-      if(posmillepatte.x > 1000 || posmillepatte.y > 1000 || posmillepatte.x < 0 || posmillepatte.y < 0){
-	afficherLutin(gameover,400,400);
-	majSurface();
-	sleep(5);
-	fermerSurface();
-	}
-      enfiler(&listecenti,&posmillepatte,sizeof(posmillepatte));
-      afficherLutin(Teteh,posmillepatte.x,posmillepatte.y);
-     majSurface();
-	s=1;
-    }
-
-    if((t==2 && s!=0) || s==2) {
-      printf("dans le gauche\n");
-      pos = premier(&listecenti);
-      afficherLutin(gomme,pos->x,pos->y);
-      defiler(&listecenti);
-      
-      pos = dernier(&listecenti);
-      afficherLutin(gomme,pos->x,pos->y);
-      afficherLutin(Corpsg,(pos->x),pos->y);
-      posmillepatte.x = pos->x-50;
-      posmillepatte.y = pos->y;
-      if(posmillepatte.x > 1000 || posmillepatte.y > 1000 || posmillepatte.x < 0 || posmillepatte.y < 0){
-	afficherLutin(gameover,400,400);
-	majSurface();
-	sleep(5);
-	fermerSurface();
-	}
-      enfiler(&listecenti,&posmillepatte,sizeof(posmillepatte));
-      afficherLutin(Teteg,posmillepatte.x,posmillepatte.y);
-     majSurface();
-	s=2;
-    }
-
-    if((t==3 && s!=1) || s==3) {
-      printf("dans le bas\n");
-      pos = premier(&listecenti);
-      afficherLutin(gomme,pos->x,pos->y);
-      defiler(&listecenti);
-      
-      pos = dernier(&listecenti);
-      afficherLutin(gomme,pos->x,pos->y);
-      afficherLutin(Corpsb,(pos->x),pos->y);
-      posmillepatte.x = pos->x;
-      posmillepatte.y = pos->y+50;
-      if(posmillepatte.x > 1000 || posmillepatte.y > 1000 || posmillepatte.x < 0 || posmillepatte.y < 0){
-	afficherLutin(gameover,400,400);
-	majSurface();
-	sleep(5);
-	fermerSurface();
-	}
-      enfiler(&listecenti,&posmillepatte,sizeof(posmillepatte));
-      afficherLutin(Teteb,posmillepatte.x,posmillepatte.y);
-     majSurface();
-	s=3;
-    }
-    
-    if(touche=='a')
-    {
-      fermerSurface();		//condition d'arret
-      return 0;
-      
-    }
-}
-
-  
-  return 0;
-}
-  
-  
@@ -7,11 +7,14 @@
 #include <SDL/SDL.h>
 #define MAX_ELEMENTS 50
  
-typedef struct{
+typedef struct {
   char pseudo[MAX_ELEMENTS];
-  int scorefait;
+  char score;
 }scorejoueur;
  
+typedef struct {
+  scorejoueur classement[10];
+}classement;
  
 typedef struct {
   int x;
@@ -32,16 +35,6 @@ for(i = 0 ; i &lt; 20; i++)
 	    rectanglePlein(i*50,0,1,1000,5);			//pose de la grille
 	    rectanglePlein(0,i*50,1000,1,5);
 	    } }
-	   
-
-void affichage(element_t e)
-{ 
-  position *p = e;
-  printf("%d %d \n", p->x, p->y);
-}
-
-
-
  
 void creerchampignons(int n,liste_poly *muschrooms,int champi){
       position poschampi;
@@ -96,10 +89,11 @@ int main() {
   unsigned char bas;
   int largeur = 1000;
   int hauteur = 1000;
-  char *name;
   char *titre = "Le Centipede";
-  scorejoueur resultat;
-  liste_poly testscore;
+  scorejoueur scorefait={.pseudo={'\0'}};
+  scorejoueur autres;
+  scorejoueur lecture;
+  classement ranking;
   position *pos;
   position posmillepatte;
  
@@ -121,21 +115,16 @@ int main() {
   int youwin = chargerLutin("Lutins/youwin.bmp",0);
   int Tete;
   int Corps;
-  int i;
-  int abs, ord, obstacle, couleur,level=1,speed=5000,total=0,nombrechampis=6, s;
+  int abs, ord, obstacle, couleur,level=1,speed=5000,total=0,nombrechampis=6, s,ecriture=1,j,w,i;
  
   if(champi<0 || Teted<0 || Teteg<0 || Teteh <0 || Teteb<0 || Corpsg<0 || Corpsd<0 || Corpsh<0 || Corpsb<0 || gameover<0 || level1<0 || level2<0 || level3<0 || levelclr<0 || youwin<0){ printf("Image pas là\n"); exit(-1); }
-  
-  printf("joueur !! quel est votre pseudo ? :");
-  scanf("%s",&name);
-  resultat.nom = name;
+
   creerSurface(largeur,hauteur,titre);
   majSurface();
   int gomme = creerLutin(0,0,50,50,-1);
  
 while(level<=3) {  
  
-  queue = 0;
   liste_poly muschrooms={.nombre=0};
   liste_t listecenti={NULL,0,0};
   int w,t,compteur=0,allonge;
@@ -245,29 +234,68 @@ while(level&lt;=3) {
 	speed = speed/2.2;
 	level++;
  
-} 
+}
+
   printf("votre score est de %d\n",total);
-  resultat.scorefait = total;
-  
-  FILE *fichier = NULL;
-  fichier = fopen("scores.txt",r+);
-  
-  if(fichier==NULL) { printf("\n le fichier n'a pas plus etre ouvert"); fermerSurface(); }
-  
-  else{
-    
-    testscore->contenu[testscore->nombre++]=fread;
-    
-    
-  
-  
-  
-  }
-  
-  
-  fermerSurface();
-  fclose(fichier);
+
+   for(i=0;i<10;i++) // initialisation de la liste classement
+    {
+      strcpy(ranking.classement[i].pseudo,"vide");
+      ranking.classement[i].score=0;
+    }
+
+      fermerSurface();
+      printf("Saisissez votre pseudo\n");
+      scanf("%s",scorefait.pseudo);
+      scorefait.score=total;
+
+
+    FILE *fichier=fopen("scores.txt","a+");  // Gestion fichier
+    fclose(fichier);
+    fichier=fopen("scores.txt","r+");
+    if(fichier!=NULL){
+
+      while((fread(&autres,sizeof(autres),1,fichier)!=0))
+      {
+	if(strcmp(autres.pseudo,scorefait.pseudo)==0)
+	{
+	  if(total>autres.score)
+	  {
+	    fseek(fichier,-sizeof(scorefait),SEEK_CUR);
+	    fwrite(&scorefait,sizeof(scorefait),1,fichier);
+	  }
+	  ecriture=0;
+	  break;
+	}
+	ecriture=1;
+      }
+      if(ecriture==1) {fwrite(&scorefait,sizeof(scorefait),1,fichier);}
+    }
+    rewind(fichier);
+    while((fread(&lecture,sizeof(lecture),1,fichier)!=0))
+    {
+      for(w=0;w<10;w++)
+      {
+	if(lecture.score>ranking.classement[w].score)
+	{
+	  for(j=10;j>w;j--)
+	  {
+	    strcpy(ranking.classement[j].pseudo,ranking.classement[j-1].pseudo);         // gestion et affichage classement
+	    ranking.classement[j].score=ranking.classement[j-1].score;
+	  }
+	  strcpy(ranking.classement[w].pseudo,lecture.pseudo);
+	  ranking.classement[w].score=lecture.score;
+	  break;
+	}
+      }
+    }
+    printf("RANKING :\n");
+    for(w=0;w<10;w++) 
+    {
+      printf("%i : %s , score : %d\n",w+1,ranking.classement[w].pseudo,ranking.classement[w].score);
+    }
+    fclose(fichier);
+
   return 0;
 }
  
-  
 \ No newline at end of file
@@ -0,0 +1,301 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <libFile.h>
+#include <libgraph.h>
+#include <unistd.h>
+#include <time.h>
+#include <SDL/SDL.h>
+#define MAX_ELEMENTS 50
+
+typedef struct {
+  char pseudo[MAX_ELEMENTS];
+  char score;
+}scorejoueur;
+
+typedef struct {
+  scorejoueur classement[10];
+}classement;
+
+typedef struct {
+  int x;
+  int y;
+}position;
+
+
+typedef struct {
+  position contenu[MAX_ELEMENTS];
+  int nombre;
+  } liste_poly;
+  
+    
+void creationgrille(){
+int i;
+for(i = 0 ; i < 20; i++)
+	    {
+	    rectanglePlein(i*50,0,1,1000,5);			//pose de la grille
+	    rectanglePlein(0,i*50,1000,1,5);
+	    } }
+
+void creerchampignons(int n,liste_poly *muschrooms,int champi){
+      position poschampi;
+      int i,w;
+      int test=0;
+      for(w=0;w<n;w++) 
+	    {
+	    poschampi.x = (rand()%20)*50;			//fixe coordonnées des champignons
+	    poschampi.y = (rand()%20)*50;
+	    for(i=0; i<w; i++){
+		if(muschrooms->contenu[i].x == poschampi.x && muschrooms->contenu[i].y == poschampi.y ) test=1;
+	    }
+	    if((poschampi.y > 570 || poschampi.y < 430) && test==0) 
+		{
+		muschrooms->contenu[muschrooms->nombre++]=poschampi;
+		afficherLutin(champi,(muschrooms->contenu[w].x)+1,(muschrooms->contenu[w].y)+6);
+		}
+	    else w--;
+	    test = 0;
+	    }
+}
+	    
+
+void creationcenti(liste_t *l, int Teted, int Corpsd){
+      int i;
+      position *pos;
+      position posmillepatte;
+      for(i=0; i<4; i++)
+	    {
+	    posmillepatte.x = (300 + 50*i);
+	    posmillepatte.y = 500;
+	    enfiler(l,&posmillepatte,sizeof(position));
+	    }
+							//affichage des corpsd du centipede
+      for(i=0; i<4; i++)
+	    {
+	    pos = enieme(i,l);
+	    afficherLutin(Corpsd,pos->x,pos->y);
+	    }
+    
+  posmillepatte.x = 500;
+  posmillepatte.y = 500;
+  enfiler(l,&posmillepatte,sizeof(position)); //affichage de la tete du Centipède
+  pos = enieme(4,l);
+  afficherLutin(Teted,pos->x,pos->y); 
+}
+
+int main() {
+  SDL_keysym* detail;
+  srand(time(NULL));
+  char touche;
+  unsigned char bas;
+  int largeur = 1000;
+  int hauteur = 1000;
+  char *titre = "Le Centipede";
+  scorejoueur scorefait={.pseudo={'\0'}};
+  scorejoueur autres;
+  scorejoueur lecture;
+  classement ranking;
+  position *pos;
+  position posmillepatte;
+  
+  
+  int champi = chargerLutin("Lutins/millepatte_champi.bmp",0);
+  int Teted = chargerLutin("Lutins/millepatte_tete_droite.bmp",0);
+  int Teteg = chargerLutin("Lutins/millepatte_tete_gauche.bmp",0);
+  int Teteh = chargerLutin("Lutins/millepatte_tete_haut.bmp",0);
+  int Teteb = chargerLutin("Lutins/millepatte_tete_bas.bmp",0);
+  int Corpsg = chargerLutin("Lutins/millepatte_corps_gauche.bmp",0);
+  int Corpsd = chargerLutin("Lutins/millepatte_corps_droite.bmp",0);
+  int Corpsh = chargerLutin("Lutins/millepatte_corps_haut.bmp",0);
+  int Corpsb = chargerLutin("Lutins/millepatte_corps_bas.bmp",0);
+  int gameover = chargerLutin("Lutins/game_over.bmp",0);
+  int level1 = chargerLutin("Lutins/level1.bmp",0);
+  int level2 = chargerLutin("Lutins/level2.bmp",0);
+  int level3 = chargerLutin("Lutins/level3.bmp",0);
+  int levelclr = chargerLutin("Lutins/level_cleared.bmp",0);
+  int youwin = chargerLutin("Lutins/youwin.bmp",0);
+  int Tete;
+  int Corps;
+  int abs, ord, obstacle, couleur,level=1,speed=5000,total=0,nombrechampis=6, s,ecriture=1,j,w,i;
+   
+  if(champi<0 || Teted<0 || Teteg<0 || Teteh <0 || Teteb<0 || Corpsg<0 || Corpsd<0 || Corpsh<0 || Corpsb<0 || gameover<0 || level1<0 || level2<0 || level3<0 || levelclr<0 || youwin<0){ printf("Image pas là\n"); exit(-1); }
+
+  creerSurface(largeur,hauteur,titre);
+  majSurface();
+  int gomme = creerLutin(0,0,50,50,-1);
+ 
+while(level<=3) {  
+  
+  liste_poly muschrooms={.nombre=0};
+  liste_t listecenti={NULL,0,0};
+  int w,t,compteur=0,allonge;
+  
+  rectanglePlein(0,0,1000,1000,1);
+  
+  if(level==1) { afficherLutin(level1,250,250); majSurface(); sleep(1); }
+  if(level==2) { afficherLutin(level2,250,250); majSurface(); sleep(1); }
+  if(level==3) { afficherLutin(level3,250,250); majSurface(); sleep(1); }
+  
+  rectanglePlein(0,0,1000,1000,-1);
+  
+  creationcenti(&listecenti,Teted,Corpsd);
+  
+  creerchampignons(nombrechampis,&muschrooms,champi);
+	    
+  majSurface();
+  
+  attendreEvenement();
+  
+  s = 0;
+  t = 0;
+  
+  while(1){
+	for(i=0;i<speed;i++)
+	{
+	  if(lireTouche(&bas,&touche,(void **)&detail) && bas==1) 
+	      {
+	      if(detail->sym==SDLK_RIGHT) t=0;
+	      if(detail->sym==SDLK_UP) t=1;
+	      if(detail->sym==SDLK_LEFT) t=2;
+	      if(detail->sym==SDLK_DOWN) t=3;	
+	      }
+ 	
+	  usleep(1);
+	}
+	  if((t==0 && s!=2) || s==0) { abs=50; ord=0; Tete = Teted; Corps = Corpsd; s=0; }
+	  if((t==1 && s!=3) || s==1) { abs=0; ord=(-50); Tete = Teteh; Corps = Corpsh; s=1; }
+	  if((t==2 && s!=0) || s==2) { abs=-50; ord=0; Tete = Teteg; Corps = Corpsg; s=2; }
+	  if((t==3 && s!=1) || s==3) { abs=0; ord=50; Tete = Teteb; Corps = Corpsb; s=3; }  
+	  
+	      pos = dernier(&listecenti);
+	      posmillepatte.x = pos->x+abs;
+	      posmillepatte.y = pos->y+ord;
+	      if(posmillepatte.x==1000 || posmillepatte.y==1000 || posmillepatte.x==-50 || posmillepatte.y==-50)
+		  {
+		  afficherLutin(gameover,250,433);
+		  majSurface();
+		  sleep(5);
+		  break;
+		  }
+
+	      majSurface();
+	      couleur = couleurPixel(posmillepatte.x+25,posmillepatte.y+25);
+	      if(couleur!=1) obstacle = 1;
+	      else obstacle = 0;
+	      allonge = 0;
+	      
+	      if(obstacle==1){
+		 for(w=0;w<nombrechampis;w++)
+		    {
+			if((muschrooms.contenu[w].x) == posmillepatte.x && (muschrooms.contenu[w].y) == posmillepatte.y) { allonge = 1; } }
+			if(allonge==1){
+			afficherLutin(gomme,posmillepatte.x,posmillepatte.y);  
+			afficherLutin(gomme,pos->x,pos->y);
+			afficherLutin(Corps,(pos->x),pos->y);
+			enfiler(&listecenti,&posmillepatte,sizeof(posmillepatte));
+			afficherLutin(Tete,posmillepatte.x,posmillepatte.y);
+			compteur++;
+			}
+			else {
+			afficherLutin(gameover,250,433);
+			majSurface();
+			sleep(5);
+			break;
+			}		
+		
+	      }
+	      
+	      if(obstacle==0){
+		afficherLutin(gomme,pos->x,pos->y);
+		afficherLutin(Corps,(pos->x),pos->y);
+		enfiler(&listecenti,&posmillepatte,sizeof(posmillepatte));
+		afficherLutin(Tete,posmillepatte.x,posmillepatte.y);
+	        pos = premier(&listecenti);
+	        afficherLutin(gomme,pos->x,pos->y);
+	        defiler(&listecenti);
+	      }
+	      majSurface();
+	      
+	      if(compteur==nombrechampis) break;
+    
+	      if(touche=='a')
+		  {
+		  fermerSurface();		//condition d'arret
+		  return 0;    
+		  }
+	}
+	
+	
+	total = total+compteur;
+	if(compteur != nombrechampis) break;
+	if(level==3) { afficherLutin(youwin,204,400); majSurface(); sleep(3); }
+	else { afficherLutin(levelclr,304,454); majSurface(); sleep(3); }
+	compteur = 0;
+	nombrechampis = nombrechampis+3;
+	speed = speed/2.2;
+	level++;
+  
+}
+
+  printf("votre score est de %d\n",total);
+
+   for(i=0;i<10;i++) // initialisation de la liste classement
+    {
+      strcpy(ranking.classement[i].pseudo,"vide");
+      ranking.classement[i].score=0;
+    }
+
+      fermerSurface();
+      printf("Saisissez votre pseudo\n");
+      scanf("%s",scorefait.pseudo);
+      scorefait.score=total;
+
+
+    FILE *fichier=fopen("scores.txt","a+");  // Gestion fichier
+    fclose(fichier);
+    fichier=fopen("scores.txt","r+");
+    if(fichier!=NULL){
+
+      while((fread(&autres,sizeof(autres),1,fichier)!=0))
+      {
+	if(strcmp(autres.pseudo,scorefait.pseudo)==0)
+	{
+	  if(total>autres.score)
+	  {
+	    fseek(fichier,-sizeof(scorefait),SEEK_CUR);
+	    fwrite(&scorefait,sizeof(scorefait),1,fichier);
+	  }
+	  ecriture=0;
+	  break;
+	}
+	ecriture=1;
+      }
+      if(ecriture==1) {fwrite(&scorefait,sizeof(scorefait),1,fichier);}
+    }
+    rewind(fichier);
+    while((fread(&lecture,sizeof(lecture),1,fichier)!=0))
+    {
+      for(w=0;w<10;w++)
+      {
+	if(lecture.score>ranking.classement[w].score)
+	{
+	  for(j=10;j>w;j--)
+	  {
+	    strcpy(ranking.classement[j].pseudo,ranking.classement[j-1].pseudo);         // gestion et affichage classement
+	    ranking.classement[j].score=ranking.classement[j-1].score;
+	  }
+	  strcpy(ranking.classement[w].pseudo,lecture.pseudo);
+	  ranking.classement[w].score=lecture.score;
+	  break;
+	}
+      }
+    }
+    printf("RANKING :\n");
+    for(w=0;w<10;w++) 
+    {
+      printf("%i : %s , score : %d\n",w+1,ranking.classement[w].pseudo,ranking.classement[w].score);
+    }
+    fclose(fichier);
+
+  return 0;
+}
+  
@@ -0,0 +1,13 @@
+SOURCES = $(wildcard *.c)
+OBJETS = $(SOURCES:.c=.o)
+BIBLIOTHEQUES = -L ../Liste -lListe -L ../Graphique -lgraph
+EXECUTABLE = centipede
+CFLAGS += -Wall -I ../Liste -I ../Graphique
+
+all: $(EXECUTABLE)
+
+$(EXECUTABLE): $(OBJETS)
+	$(CC) -o $@ $^ $(BIBLIOTHEQUES) -lSDL
+
+clean:
+	rm -rf $(EXECUTABLE) *.o
@@ -0,0 +1,302 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <libFile.h>
+#include <libgraph.h>
+#include <unistd.h>
+#include <time.h>
+#include <SDL/SDL.h>
+#define MAX_ELEMENTS 50
+
+typedef struct {
+  char pseudo[MAX_ELEMENTS];
+  char score;
+}scorejoueur;
+
+typedef struct {
+  scorejoueur classement[10];
+}classement;
+
+typedef struct {
+  int x;
+  int y;
+}position;
+
+typedef struct {
+  position contenu[MAX_ELEMENTS];
+  int nombre;
+  } liste_poly;
+  
+    
+void creationgrille(){
+int i;
+for(i = 0 ; i < 20; i++)
+	    {
+	    rectanglePlein(i*50,0,1,1000,5);			//pose de la grille
+	    rectanglePlein(0,i*50,1000,1,5);
+	    } }
+	   
+
+void affichage(element_t e)
+{ 
+  position *p = e;
+  printf("%d %d \n", p->x, p->y);
+}
+
+
+void creerchampignons(int n,liste_poly *muschrooms,int champi){
+      position poschampi;
+      int i,w;
+      int test=0;
+      for(w=0;w<n;w++) 
+	    {
+	    poschampi.x = (rand()%20)*50;			//fonction de pose des champignons
+	    poschampi.y = (rand()%20)*50;
+	    for(i=0; i<w; i++){
+		if(muschrooms->contenu[i].x == poschampi.x && muschrooms->contenu[i].y == poschampi.y ) test=1;
+	    }
+	    if((poschampi.y > 570 || poschampi.y < 430) && test==0) 
+		{
+		muschrooms->contenu[muschrooms->nombre++]=poschampi;
+		afficherLutin(champi,(muschrooms->contenu[w].x)+1,(muschrooms->contenu[w].y)+6);
+		}
+	    else w--;
+	    test = 0;
+	    }
+}
+
+
+void creationcenti(Liste *liste,int Teted, int Corpsd) {
+      int x,y=500;
+      for(x = 300 ; x <= 450 ; x=x+50) {     // fonction pour la creation centipede liste chainée
+      insertion(liste, x, y);
+      afficherLutin(Corpsd,x,y); }
+      x = 500; 
+      afficherLutin(Teted,x,y);
+      insertion(liste, x, y);
+}
+
+
+int main() {
+  SDL_keysym* detail;
+  srand(time(NULL));
+  char touche;
+  unsigned char bas;
+  int largeur = 1000;
+  int hauteur = 1000;
+  char *titre = "Le Centipede";
+  scorejoueur scorefait={.pseudo={'\0'}};
+  scorejoueur autres;
+  scorejoueur lecture;
+  classement ranking;
+  
+  int champi = chargerLutin("Lutins/millepatte_champi.bmp",0);
+  int Teted = chargerLutin("Lutins/millepatte_tete_droite.bmp",0);
+  int Teteg = chargerLutin("Lutins/millepatte_tete_gauche.bmp",0);
+  int Teteh = chargerLutin("Lutins/millepatte_tete_haut.bmp",0);
+  int Teteb = chargerLutin("Lutins/millepatte_tete_bas.bmp",0);
+  int Corpsg = chargerLutin("Lutins/millepatte_corps_gauche.bmp",0);
+  int Corpsd = chargerLutin("Lutins/millepatte_corps_droite.bmp",0);
+  int Corpsh = chargerLutin("Lutins/millepatte_corps_haut.bmp",0);
+  int Corpsb = chargerLutin("Lutins/millepatte_corps_bas.bmp",0);
+  int gameover = chargerLutin("Lutins/game_over.bmp",0);
+  int level1 = chargerLutin("Lutins/level1.bmp",0);
+  int level2 = chargerLutin("Lutins/level2.bmp",0);
+  int level3 = chargerLutin("Lutins/level3.bmp",0);
+  int levelclr = chargerLutin("Lutins/level_cleared.bmp",0);
+  int youwin = chargerLutin("Lutins/youwin.bmp",0);
+  int Tete;
+  int Corps;
+  int i;
+  int abs, ord, obstacle=0, couleur,level=1,speed=5000,total=0,nombrechampis=6, s,nvx,nvy,abscenti,ordcenti,absqueue,ordqueue,ecriture=1,j,w;
+   
+  if(champi<0 || Teted<0 || Teteg<0 || Teteh <0 || Teteb<0 || Corpsg<0 || Corpsd<0 || Corpsh<0 || Corpsb<0 || gameover<0 || level1<0 || level2<0 || level3<0 || levelclr<0 || youwin<0){ printf("Image pas là\n"); exit(-1); }
+  
+  creerSurface(largeur,hauteur,titre);
+  majSurface();
+  int gomme = creerLutin(0,0,50,50,-1);
+ 
+while(level<=3) {  
+  
+  liste_poly muschrooms={.nombre=0};
+  Liste *maListe = initialisation();
+  int w,t,compteur=0,allonge;
+  
+  rectanglePlein(0,0,1000,1000,1);
+  rectanglePlein(0,0,1000,1000,1);
+  
+  
+  if(level==1) { afficherLutin(level1,250,250); majSurface(); sleep(1); }
+  if(level==2) { afficherLutin(level2,250,250); majSurface(); sleep(1); }
+  if(level==3) { afficherLutin(level3,250,250); majSurface(); sleep(1); }
+  
+  rectanglePlein(0,0,1000,1000,1);
+  rectanglePlein(0,0,1000,1000,1);
+  
+  creationcenti(maListe,Teted,Corpsd);
+  
+  creerchampignons(nombrechampis,&muschrooms,champi);
+	    
+  majSurface();
+  
+  attendreEvenement();
+  
+  s = 0;
+  t = 0;
+  
+  while(1){
+    
+	for(i=0;i<speed;i++)
+	{
+	  if(lireTouche(&bas,&touche,(void **)&detail) && bas==1) 
+	      {
+	      if(detail->sym==SDLK_RIGHT) t=0;
+	      if(detail->sym==SDLK_UP) t=1;
+	      if(detail->sym==SDLK_LEFT) t=2;
+	      if(detail->sym==SDLK_DOWN) t=3;	
+	      }
+ 	
+	  usleep(1);
+	}
+	  if((t==0 && s!=2) || s==0) { abs=50; ord=0; Tete = Teted; Corps = Corpsd; s=0; }
+	  if((t==1 && s!=3) || s==1) { abs=0; ord=(-50); Tete = Teteh; Corps = Corpsh; s=1; }
+	  if((t==2 && s!=0) || s==2) { abs=-50; ord=0; Tete = Teteg; Corps = Corpsg; s=2; }
+	  if((t==3 && s!=1) || s==3) { abs=0; ord=50; Tete = Teteb; Corps = Corpsb; s=3; }  
+	  
+	      abscenti = abstete(maListe);
+	      ordcenti = ordtete(maListe);
+	      nvx = abscenti+abs;
+	      nvy = ordcenti+ord;
+	      if(nvx==1000 || nvy==1000 || nvx==-50 || nvy==-50)
+		  {
+		  afficherLutin(gameover,250,433);
+		  majSurface();
+		  sleep(5);
+		  break;
+		  }
+
+	      majSurface();
+	      couleur = couleurPixel(nvx+25,nvy+25);
+	      if(couleur!=1) obstacle = 1;
+	      else obstacle = 0;
+	      allonge = 0;
+	      
+	      
+	      if(obstacle==1){
+		 for(w=0;w<nombrechampis;w++)
+		    {
+			if((muschrooms.contenu[w].x) == nvx && (muschrooms.contenu[w].y) == nvy) { allonge = 1; } }
+			if(allonge==1){
+			afficherLutin(gomme,nvx,nvy);  
+			afficherLutin(gomme,abscenti,ordcenti);
+			afficherLutin(Corps,abscenti,ordcenti);
+			insertion(maListe,nvx,nvy);
+			afficherLutin(Tete,nvx,nvy);
+			compteur++;
+			}
+			else {
+			afficherLutin(gameover,250,433);
+			majSurface();
+			sleep(5);
+			break;
+			}		
+	
+		
+	      }
+	      
+	      if(obstacle==0){
+		afficherLutin(gomme,abscenti,ordcenti);
+		afficherLutin(Corps,abscenti,ordcenti);
+		absqueue = abscul(maListe);
+		ordqueue = ordcul(maListe);
+		freelastbloc(maListe);
+		insertion(maListe,nvx,nvy);
+		afficherLutin(Tete,nvx,nvy);
+	        afficherLutin(gomme,absqueue,ordqueue);
+	      }
+	      
+	      majSurface();
+	      
+	      if(compteur==nombrechampis) break;
+    
+	      if(touche=='a')
+		  {
+		  fermerSurface();
+		  return 0;    
+		  }
+	}
+	
+	
+	total = total+compteur;
+	if(compteur != nombrechampis) break;
+	if(level==3) { afficherLutin(youwin,204,400); majSurface(); sleep(3); }
+	else { afficherLutin(levelclr,304,454); majSurface(); sleep(3); }
+	compteur = 0;
+	nombrechampis = nombrechampis+3;
+	speed = speed/2;
+	level++;
+	freeListe(maListe);
+}
+  printf("votre score est de %d\n",total);
+
+   for(i=0;i<10;i++) // initialisation de la liste classement
+    {
+      strcpy(ranking.classement[i].pseudo,"vide");
+      ranking.classement[i].score=0;
+    }
+
+      fermerSurface();
+      printf("Saisissez votre pseudo\n");
+      scanf("%s",scorefait.pseudo);
+      scorefait.score=total;
+
+
+    FILE *fichier=fopen("scores.txt","a+");  // Gestion fichier
+    fclose(fichier);
+    fichier=fopen("scores.txt","r+");
+    if(fichier!=NULL){
+
+      while((fread(&autres,sizeof(autres),1,fichier)!=0))
+      {
+	if(strcmp(autres.pseudo,scorefait.pseudo)==0)
+	{
+	  if(total>autres.score)
+	  {
+	    fseek(fichier,-sizeof(scorefait),SEEK_CUR);
+	    fwrite(&scorefait,sizeof(scorefait),1,fichier);
+	  }
+	  ecriture=0;
+	  break;
+	}
+	ecriture=1;
+      }
+      if(ecriture==1) {fwrite(&scorefait,sizeof(scorefait),1,fichier);}
+    }
+    rewind(fichier);
+    while((fread(&lecture,sizeof(lecture),1,fichier)!=0))
+    {
+      for(w=0;w<10;w++)
+      {
+	if(lecture.score>ranking.classement[w].score)
+	{
+	  for(j=10;j>w;j--)
+	  {
+	    strcpy(ranking.classement[j].pseudo,ranking.classement[j-1].pseudo);         // gestion et affichage classement
+	    ranking.classement[j].score=ranking.classement[j-1].score;
+	  }
+	  strcpy(ranking.classement[w].pseudo,lecture.pseudo);
+	  ranking.classement[w].score=lecture.score;
+	  break;
+	}
+      }
+    }
+    printf("RANKING :\n");
+    for(w=0;w<10;w++) 
+    {
+      printf("%i : %s , score : %d\n",w+1,ranking.classement[w].pseudo,ranking.classement[w].score);
+    }
+    fclose(fichier);
+
+  return 0;
+}
+  
+  
@@ -0,0 +1,304 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <libFile.h>
+#include <libgraph.h>
+#include <unistd.h>
+#include <time.h>
+#include <SDL/SDL.h>
+#define MAX_ELEMENTS 50
+
+typedef struct {
+  char pseudo[MAX_ELEMENTS];
+  char score;
+}scorejoueur;
+
+typedef struct {
+  scorejoueur classement[10];
+}classement;
+
+typedef struct {
+  int x;
+  int y;
+}position;
+
+typedef struct {
+  position contenu[MAX_ELEMENTS];
+  int nombre;
+  } liste_poly;
+  
+    
+void creationgrille(){
+int i;
+for(i = 0 ; i < 20; i++)
+	    {
+	    rectanglePlein(i*50,0,1,1000,5);			//pose de la grille
+	    rectanglePlein(0,i*50,1000,1,5);
+	    } }
+	   
+
+void affichage(element_t e)
+{ 
+  position *p = e;
+  printf("%d %d \n", p->x, p->y);
+}
+
+
+void creerchampignons(int n,liste_poly *muschrooms,int champi){
+      position poschampi;
+      int i,w;
+      int test=0;
+      for(w=0;w<n;w++) 
+	    {
+	    poschampi.x = (rand()%20)*50;			//fonction de pose des champignons
+	    poschampi.y = (rand()%20)*50;
+	    for(i=0; i<w; i++){
+		if(muschrooms->contenu[i].x == poschampi.x && muschrooms->contenu[i].y == poschampi.y ) test=1;
+	    }
+	    if((poschampi.y > 570 || poschampi.y < 430) && test==0) 
+		{
+		muschrooms->contenu[muschrooms->nombre++]=poschampi;
+		afficherLutin(champi,(muschrooms->contenu[w].x)+1,(muschrooms->contenu[w].y)+6);
+		}
+	    else w--;
+	    test = 0;
+	    }
+}
+
+
+void creationcenti(Liste *liste,int Teted, int Corpsd) {
+      int x,y=500;
+      for(x = 300 ; x <= 450 ; x=x+50) {     // fonction pour la creation centipede liste chainée
+      insertion(liste, x, y);
+      afficherLutin(Corpsd,x,y); }
+      x = 500; 
+      afficherLutin(Teted,x,y);
+      insertion(liste, x, y);
+}
+
+
+int main() {
+  SDL_keysym* detail;
+  srand(time(NULL));
+  char touche;
+  unsigned char bas;
+  int largeur = 1000;
+  int hauteur = 1000;
+  char *titre = "Le Centipede";
+  position *pos;
+  position posmillepatte;
+  scorejoueur scorefait={.pseudo={'\0'}};
+  scorejoueur autres;
+  scorejoueur lecture;
+  classement ranking;
+  
+  int champi = chargerLutin("Lutins/millepatte_champi.bmp",0);
+  int Teted = chargerLutin("Lutins/millepatte_tete_droite.bmp",0);
+  int Teteg = chargerLutin("Lutins/millepatte_tete_gauche.bmp",0);
+  int Teteh = chargerLutin("Lutins/millepatte_tete_haut.bmp",0);
+  int Teteb = chargerLutin("Lutins/millepatte_tete_bas.bmp",0);
+  int Corpsg = chargerLutin("Lutins/millepatte_corps_gauche.bmp",0);
+  int Corpsd = chargerLutin("Lutins/millepatte_corps_droite.bmp",0);
+  int Corpsh = chargerLutin("Lutins/millepatte_corps_haut.bmp",0);
+  int Corpsb = chargerLutin("Lutins/millepatte_corps_bas.bmp",0);
+  int gameover = chargerLutin("Lutins/game_over.bmp",0);
+  int level1 = chargerLutin("Lutins/level1.bmp",0);
+  int level2 = chargerLutin("Lutins/level2.bmp",0);
+  int level3 = chargerLutin("Lutins/level3.bmp",0);
+  int levelclr = chargerLutin("Lutins/level_cleared.bmp",0);
+  int youwin = chargerLutin("Lutins/youwin.bmp",0);
+  int Tete;
+  int Corps;
+  int i;
+  int abs, ord, obstacle=0, couleur,level=1,speed=5000,total=0,nombrechampis=6, s,nvx,nvy,abscenti,ordcenti,absqueue,ordqueue,ecriture=1,j,w;
+   
+  if(champi<0 || Teted<0 || Teteg<0 || Teteh <0 || Teteb<0 || Corpsg<0 || Corpsd<0 || Corpsh<0 || Corpsb<0 || gameover<0 || level1<0 || level2<0 || level3<0 || levelclr<0 || youwin<0){ printf("Image pas là\n"); exit(-1); }
+  
+  creerSurface(largeur,hauteur,titre);
+  majSurface();
+  int gomme = creerLutin(0,0,50,50,-1);
+ 
+while(level<=3) {  
+  
+  liste_poly muschrooms={.nombre=0};
+  Liste *maListe = initialisation();
+  int w,t,compteur=0,allonge;
+  
+  rectanglePlein(0,0,1000,1000,1);
+  rectanglePlein(0,0,1000,1000,1);
+  
+  
+  if(level==1) { afficherLutin(level1,250,250); majSurface(); sleep(1); }
+  if(level==2) { afficherLutin(level2,250,250); majSurface(); sleep(1); }
+  if(level==3) { afficherLutin(level3,250,250); majSurface(); sleep(1); }
+  
+  rectanglePlein(0,0,1000,1000,1);
+  rectanglePlein(0,0,1000,1000,1);
+  
+  creationcenti(maListe,Teted,Corpsd);
+  
+  creerchampignons(nombrechampis,&muschrooms,champi);
+	    
+  majSurface();
+  
+  attendreEvenement();
+  
+  s = 0;
+  t = 0;
+  
+  while(1){
+    
+	for(i=0;i<speed;i++)
+	{
+	  if(lireTouche(&bas,&touche,(void **)&detail) && bas==1) 
+	      {
+	      if(detail->sym==SDLK_RIGHT) t=0;
+	      if(detail->sym==SDLK_UP) t=1;
+	      if(detail->sym==SDLK_LEFT) t=2;
+	      if(detail->sym==SDLK_DOWN) t=3;	
+	      }
+ 	
+	  usleep(1);
+	}
+	  if((t==0 && s!=2) || s==0) { abs=50; ord=0; Tete = Teted; Corps = Corpsd; s=0; }
+	  if((t==1 && s!=3) || s==1) { abs=0; ord=(-50); Tete = Teteh; Corps = Corpsh; s=1; }
+	  if((t==2 && s!=0) || s==2) { abs=-50; ord=0; Tete = Teteg; Corps = Corpsg; s=2; }
+	  if((t==3 && s!=1) || s==3) { abs=0; ord=50; Tete = Teteb; Corps = Corpsb; s=3; }  
+	  
+	      abscenti = abstete(maListe);
+	      ordcenti = ordtete(maListe);
+	      nvx = abscenti+abs;
+	      nvy = ordcenti+ord;
+	      if(nvx==1000 || nvy==1000 || nvx==-50 || nvy==-50)
+		  {
+		  afficherLutin(gameover,250,433);
+		  majSurface();
+		  sleep(5);
+		  break;
+		  }
+
+	      majSurface();
+	      couleur = couleurPixel(nvx+25,nvy+25);
+	      if(couleur!=1) obstacle = 1;
+	      else obstacle = 0;
+	      allonge = 0;
+	      
+	      
+	      if(obstacle==1){
+		 for(w=0;w<nombrechampis;w++)
+		    {
+			if((muschrooms.contenu[w].x) == nvx && (muschrooms.contenu[w].y) == nvy) { allonge = 1; } }
+			if(allonge==1){
+			afficherLutin(gomme,nvx,nvy);  
+			afficherLutin(gomme,abscenti,ordcenti);
+			afficherLutin(Corps,abscenti,ordcenti);
+			insertion(maListe,nvx,nvy);
+			afficherLutin(Tete,nvx,nvy);
+			compteur++;
+			}
+			else {
+			afficherLutin(gameover,250,433);
+			majSurface();
+			sleep(5);
+			break;
+			}		
+	
+		
+	      }
+	      
+	      if(obstacle==0){
+		afficherLutin(gomme,abscenti,ordcenti);
+		afficherLutin(Corps,abscenti,ordcenti);
+		absqueue = abscul(maListe);
+		ordqueue = ordcul(maListe);
+		freelastbloc(maListe);
+		insertion(maListe,nvx,nvy);
+		afficherLutin(Tete,nvx,nvy);
+	        afficherLutin(gomme,absqueue,ordqueue);
+	      }
+	      
+	      majSurface();
+	      
+	      if(compteur==nombrechampis) break;
+    
+	      if(touche=='a')
+		  {
+		  fermerSurface();
+		  return 0;    
+		  }
+	}
+	
+	
+	total = total+compteur;
+	if(compteur != nombrechampis) break;
+	if(level==3) { afficherLutin(youwin,204,400); majSurface(); sleep(3); }
+	else { afficherLutin(levelclr,304,454); majSurface(); sleep(3); }
+	compteur = 0;
+	nombrechampis = nombrechampis+3;
+	speed = speed/2;
+	level++;
+	freeListe(maListe);
+}
+  printf("votre score est de %d\n",total);
+
+   for(i=0;i<10;i++) // initialisation de la liste classement
+    {
+      strcpy(ranking.classement[i].pseudo,"vide");
+      ranking.classement[i].score=0;
+    }
+
+      fermerSurface();
+      printf("Saisissez votre pseudo\n");
+      scanf("%s",scorefait.pseudo);
+      scorefait.score=total;
+
+
+    FILE *fichier=fopen("scores.txt","a+");  // Gestion fichier
+    fclose(fichier);
+    fichier=fopen("scores.txt","r+");
+    if(fichier!=NULL){
+
+      while((fread(&autres,sizeof(autres),1,fichier)!=0))
+      {
+	if(strcmp(autres.pseudo,scorefait.pseudo)==0)
+	{
+	  if(total>autres.score)
+	  {
+	    fseek(fichier,-sizeof(scorefait),SEEK_CUR);
+	    fwrite(&scorefait,sizeof(scorefait),1,fichier);
+	  }
+	  ecriture=0;
+	  break;
+	}
+	ecriture=1;
+      }
+      if(ecriture==1) {fwrite(&scorefait,sizeof(scorefait),1,fichier);}
+    }
+    rewind(fichier);
+    while((fread(&lecture,sizeof(lecture),1,fichier)!=0))
+    {
+      for(w=0;w<10;w++)
+      {
+	if(lecture.score>ranking.classement[w].score)
+	{
+	  for(j=10;j>w;j--)
+	  {
+	    strcpy(ranking.classement[j].pseudo,ranking.classement[j-1].pseudo);         // gestion et affichage classement
+	    ranking.classement[j].score=ranking.classement[j-1].score;
+	  }
+	  strcpy(ranking.classement[w].pseudo,lecture.pseudo);
+	  ranking.classement[w].score=lecture.score;
+	  break;
+	}
+      }
+    }
+    printf("RANKING :\n");
+    for(w=0;w<10;w++) 
+    {
+      printf("%i : %s , score : %d\n",w+1,ranking.classement[w].pseudo,ranking.classement[w].score);
+    }
+    fclose(fichier);
+
+  return 0;
+}
+  
+  
@@ -0,0 +1,29 @@
+#
+# Makefile pour la bibliotheque graphique
+#
+
+SOURCES = $(wildcard *.c)
+OBJETS = $(SOURCES:.c=.o)
+CIBLE = libgraph.a
+
+#
+# Nom de la cible principale
+#
+
+all: $(CIBLE)
+
+#
+# Cible de nettoyage
+#
+
+clean: 
+	rm -f core *.o $(CIBLE)
+
+#
+# Dependances pour la bibliotheque
+#
+
+$(CIBLE): $(OBJETS)
+	$(AR) rs $@ $?
+
+$(CIBLE:.a=).o: $(CIBLE:.a=).c $(CIBLE:.a=).h
@@ -0,0 +1,180 @@
+/**** Bibliotheque graphique ****/
+
+/** Fichiers d'inclusion **/
+
+#include <SDL/SDL.h>
+
+#include "libgraph.h"
+
+/** Types **/
+
+typedef struct { int r,v,b; } couleur;
+
+/** Constantes **/
+
+#define BITS_PAR_PIXEL	32
+
+static const couleur couleurs[]={
+  {255,255,255},
+  {0,0,0},
+  {255,0,0},
+  {0,255,0},
+  {0,0,255},
+  {255,105,180},
+  {150,150,150},
+  {-1,-1,-1}
+  };
+
+/** Variables globales **/
+
+static SDL_Surface *surface;
+
+/** Fonctions **/
+
+/* Initialisation de la surface dessinable */
+
+unsigned char creerSurface(int largeur,int hauteur,char *titre){
+SDL_Init(SDL_INIT_VIDEO);
+SDL_WM_SetCaption(titre,titre);
+surface=SDL_SetVideoMode(largeur,hauteur,BITS_PAR_PIXEL,SDL_DOUBLEBUF);
+return (surface!=NULL);
+}
+
+/* Fermeture de la surface dessinable */
+
+void fermerSurface(void){
+if(surface!=NULL) SDL_FreeSurface(surface);
+SDL_Quit();
+}
+
+/* Creation d'une couleur */
+
+static int creerCouleur(int ncouleur){
+couleur c=couleurs[ncouleur];
+return SDL_MapRGB(surface->format,c.r,c.v,c.b);
+}
+
+/* Dessin d'un rectangle plein */
+
+void rectanglePlein(int x,int y,int l,int h,int c){
+SDL_Rect rectangle={x,y,l,h};
+SDL_FillRect(surface,&rectangle,creerCouleur(c));
+//SDL_Flip(surface);
+}
+
+/* Manipulation de lutins */
+
+static SDL_Surface *lutins[MAX_LUTINS];
+static int lutins_nb=0;
+
+static void configurerLutin(SDL_Surface *lutin,int ncouleur){
+couleur c=couleurs[ncouleur];
+int fond=SDL_MapRGB(lutin->format,c.r,c.v,c.b);
+SDL_SetColorKey(lutin,SDL_SRCCOLORKEY|SDL_RLEACCEL,fond);
+}
+
+int chargerLutin(char *fichier,int couleur){
+if(lutins_nb>=MAX_LUTINS) return -2;
+SDL_Surface *lutin=SDL_LoadBMP(fichier);
+if(lutin!=NULL){
+  lutins[lutins_nb++]=lutin;
+  if(couleur>=0) configurerLutin(lutin,couleur);
+  return lutins_nb-1;
+  }
+return -1;
+}
+
+void afficherLutin(int lutin,int x,int y){
+SDL_Rect position;
+position.x=x;
+position.y=y;
+SDL_BlitSurface(lutins[lutin],NULL,surface,&position);
+}
+
+int creerLutin(int x,int y,int largeur,int hauteur,int couleur){
+if(lutins_nb>=MAX_LUTINS) return -2;
+int rmask,gmask,bmask,amask;
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+rmask=0xff000000; gmask=0x00ff0000; bmask=0x0000ff00; amask=0x000000ff;
+#else
+rmask=0x000000ff; gmask=0x0000ff00; bmask=0x00ff0000; amask=0xff000000;
+#endif
+if(couleur<0) amask=0x00000000;
+SDL_Surface *lutin=SDL_CreateRGBSurface(0,largeur,hauteur,BITS_PAR_PIXEL,rmask,gmask,bmask,amask);
+SDL_Rect fenetre;
+fenetre.x=x;
+fenetre.y=y;
+fenetre.h=hauteur;
+fenetre.w=largeur;
+SDL_BlitSurface(surface,&fenetre,lutin,NULL);
+lutins[lutins_nb++]=lutin;
+if(couleur>=0) configurerLutin(lutin,couleur);
+return lutins_nb-1;
+}
+
+void tailleLutin(int lutin,int *largeur,int *hauteur){
+*largeur=lutins[lutin]->w;
+*hauteur=lutins[lutin]->h;
+}
+
+int sauverLutin(int lutin,char *nom){ return SDL_SaveBMP(lutins[lutin],nom); }
+
+/* Manipulation de copie de surface en BMP */
+
+int sauverSurface(char *fichier){ return SDL_SaveBMP(surface,fichier); }
+
+unsigned char chargerSurface(char *fichier){
+SDL_Surface *image=SDL_LoadBMP(fichier);
+if(image!=NULL){
+  SDL_BlitSurface(image,NULL,surface,NULL);
+  SDL_Flip(surface);
+  }
+return (image!=NULL);
+}
+
+void majSurface(void){ SDL_Flip(surface); }
+
+/* Trouver la couleur d'un pixel */
+
+int couleurPixel(int x,int y){
+int bpp=surface->format->BytesPerPixel;
+Uint32 *p=(Uint32 *)(surface->pixels+y*surface->pitch+x*bpp);
+Uint8 r,v,b;
+SDL_GetRGB(*p,surface->format,&r,&v,&b);
+int i=0;
+while(1){
+  if(couleurs[i].r<0) break;
+  if(r==couleurs[i].r && v==couleurs[i].v && b==couleurs[i].b) break;
+  i++;
+  }
+if(couleurs[i].r<0) return -1; else return i;
+}
+
+/* Fonction de traitement des événements */
+
+unsigned char lireTouche(unsigned char *bas,char *touche,void **detail){
+static SDL_keysym _detail;
+SDL_Event event;
+while(SDL_PollEvent(&event)){
+  if(event.type==SDL_KEYDOWN || event.type==SDL_KEYUP){
+    *bas=(event.type==SDL_KEYDOWN)?1:0;
+    char* nom=SDL_GetKeyName(event.key.keysym.sym);
+    if(strlen(nom)==1 && nom[0]>=32 && nom[0]<128) *touche=nom[0]; else *touche=0;
+    _detail=event.key.keysym;
+    *detail=&_detail;
+    return 1;
+    }
+  }
+return 0;
+}
+
+void attendreEvenement(void){
+SDL_Event event;
+while(SDL_WaitEvent(&event))
+  switch(event.type){
+    case SDL_KEYDOWN:
+    case SDL_MOUSEBUTTONDOWN:
+    case SDL_QUIT:
+      return;
+    }
+}
@@ -0,0 +1,33 @@
+/**** Bibliotheque graphique (definitions) ****/
+
+/** Constantes **/
+
+#define COULEUR_BLANC	0
+#define COULEUR_NOIR	1
+#define COULEUR_ROUGE	2
+#define COULEUR_VERT	3
+#define COULEUR_BLEU	4
+#define COULEUR_ROSE	5
+#define COULEUR_GRIS	6
+
+#define MAX_LUTINS	16
+
+/** Prototypes **/
+
+unsigned char creerSurface(int largeur,int hauteur,char *titre);
+unsigned char chargerSurface(char *fichier);
+int sauverSurface(char *fichier);
+void majSurface(void);
+void fermerSurface(void);
+
+void rectanglePlein(int x,int y,int l,int h,int c);
+int couleurPixel(int x,int y);
+
+int chargerLutin(char *fichier,int couleur);
+void afficherLutin(int lutin,int x,int y);
+int creerLutin(int x,int y,int largeur,int hauteur,int couleur);
+int sauverLutin(int lutin,char *nom);
+void tailleLutin(int lutin,int *largeur,int *hauteur);
+
+unsigned char lireTouche(unsigned char *bas,char *touche,void **detail);
+void attendreEvenement(void);
@@ -0,0 +1,6 @@
+[Dolphin]
+Timestamp=2016,6,17,14,20,55
+Version=3
+
+[Settings]
+HiddenFilesShown=true
@@ -0,0 +1,29 @@
+#
+# Makefile pour la bibliotheque graphique
+#
+
+SOURCES = $(wildcard *.c)
+OBJETS = $(SOURCES:.c=.o)
+CIBLE = libListe.a
+
+#
+# Nom de la cible principale
+#
+
+all: $(CIBLE)
+
+#
+# Cible de nettoyage
+#
+
+clean: 
+	rm -f core *.o $(CIBLE)
+
+#
+# Dependances pour la bibliotheque
+#
+
+$(CIBLE): $(OBJETS)
+	$(AR) rs $@ $?
+
+$(CIBLE:.a=).o: $(CIBLE:.a=).c $(CIBLE:.a=).h
@@ -0,0 +1,192 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "libFile.h"
+#include <string.h>
+
+// Fonctions pour projets avec file
+
+int taille(liste_t *l)
+{
+  return l->nombre;
+}
+
+int enfiler (liste_t *l, element_t e, int taille){
+element_t nouveau=malloc(taille);
+memcpy(nouveau,e,taille);
+if (l->nombre >= l->alloue)
+      {
+      l->contenu = realloc(l->contenu, (l->alloue+300)*sizeof(element_t));
+      l->alloue+=300;
+      }
+l->contenu[l->nombre++]=nouveau;
+return 0;
+}
+
+
+
+int afficher(liste_t *l, void(*affichage)(element_t)) {
+int i;
+for(i=0; i<taille(l); i++) affichage(l->contenu[i]);
+return 0;
+}
+
+int defiler(liste_t *l)
+{
+  int i;
+  
+  if(taille(l)>=1) 
+  {
+  free(l->contenu[0]);
+      for(i=0; i < taille(l); i++)
+      {
+      l->contenu[i]=l->contenu[i+1];
+      }
+  l->nombre--;
+  } 
+  return 0; 
+}
+
+element_t premier(liste_t *l) {
+  return l->contenu[0]; }
+  
+element_t dernier(liste_t *l) {
+  return l->contenu[(l->nombre)-1];}
+  
+element_t enieme(int x, liste_t *l) {
+  return l->contenu[x];
+} 
+
+// Fonctions pour liste chainée 
+
+
+Liste *initialisation()
+{
+    Liste *liste = malloc(sizeof(*liste));
+    Element *element = malloc(sizeof(*element));
+
+    if (liste == NULL || element == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+    element->x =0;
+    element->y =0;
+    
+    element->suivant = NULL;
+    liste->premier = element;
+    liste->nbelements =0;
+
+    return liste;
+}
+
+void insertion(Liste *liste, int x, int y)
+{
+    /* Création du nouvel élément */
+    Element *nouveau = malloc(sizeof(*nouveau));
+    if (liste == NULL || nouveau == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+    nouveau->x = x;
+    nouveau->y = y;
+
+    /* Insertion de l'élément au début de la liste */
+    nouveau->suivant = liste->premier;
+    liste->premier = nouveau;
+    liste->nbelements=liste->nbelements+1;
+}
+
+void afficherListe(Liste *liste)
+{
+    if (liste == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    Element *actuel = liste->premier;
+
+    while (actuel != NULL)
+    {
+        printf("combinaison x,y : %d  ,  %d \n", actuel->x,actuel->y);
+        actuel = actuel->suivant;
+    }
+}
+
+void suppression(Liste *liste)
+{
+    if (liste == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    if (liste->premier != NULL)
+    {
+        Element *aSupprimer = liste->premier;
+        liste->premier = liste->premier->suivant;
+        free(aSupprimer);
+    }
+}
+
+int abstete(Liste *liste){
+  
+  Element *actuel = liste->premier;
+  return actuel->x;
+  
+}
+
+int tailledelachaine(Liste *liste) {
+  
+  return liste->nbelements;
+  
+}
+
+
+int ordtete(Liste *liste) {
+ Element *actuel = liste->premier;
+ return actuel->y;
+}
+
+int abscul(Liste *liste) {
+ Element *actuel = liste->premier;
+ int i;
+ for(i=1;i<liste->nbelements;i++)
+    {
+        actuel = actuel->suivant;
+    }
+ return actuel->x; 
+}
+
+int ordcul(Liste *liste) {
+ Element *actuel = liste->premier;
+ int i;
+ for(i=1;i<liste->nbelements;i++)
+    {
+        actuel = actuel->suivant;
+    }
+ return actuel->y; 
+}
+
+
+void freelastbloc(Liste *liste) {
+  int i;
+  Element *actuel = liste->premier;
+  for(i=1; i<liste->nbelements-1; i++){
+    actuel = actuel->suivant;
+  }
+  Element *asupprimer = actuel->suivant;
+  free(asupprimer);
+  actuel->suivant = NULL;
+  liste->nbelements = liste->nbelements-1;
+}
+
+
+void freeListe(Liste *liste){
+  while(liste->premier!=NULL) suppression(liste);
+}
+
+
+
+
+
+
+
+
@@ -0,0 +1,192 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "libFile.h"
+#include <string.h>
+
+// Fonctions pour projets avec file
+
+int taille(liste_t *l)
+{
+  return l->nombre;
+}
+
+int enfiler (liste_t *l, element_t e, int taille){
+element_t nouveau=malloc(taille);
+memcpy(nouveau,e,taille);
+if (l->nombre >= l->alloue)
+      {
+      l->contenu = realloc(l->contenu, (l->alloue+300)*sizeof(element_t));
+      l->alloue+=300;
+      }
+l->contenu[l->nombre++]=nouveau;
+return 0;
+}
+
+
+
+int afficher(liste_t *l, void(*affichage)(element_t)) {
+int i;
+for(i=0; i<taille(l); i++) affichage(l->contenu[i]);
+return 0;
+}
+
+int defiler(liste_t *l)
+{
+  int i;
+  
+  if(taille(l)>=1) 
+  {
+  free(l->contenu[0]);
+      for(i=0; i < taille(l); i++)
+      {
+      l->contenu[i]=l->contenu[i+1];
+      }
+  l->nombre--;
+  } 
+  return 0; 
+}
+
+element_t premier(liste_t *l) {
+  return l->contenu[0]; }
+  
+element_t dernier(liste_t *l) {
+  return l->contenu[(l->nombre)-1];}
+  
+element_t enieme(int x, liste_t *l) {
+  return l->contenu[x];
+} 
+
+// Fonctions pour liste chainée 
+
+
+Liste *initialisation()
+{
+    Liste *liste = malloc(sizeof(*liste));
+    Element *element = malloc(sizeof(*element));
+
+    if (liste == NULL || element == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+    element->x =0;
+    element->y =0;
+    
+    element->suivant = NULL;
+    liste->premier = element;
+    liste->nbelements =0;
+
+    return liste;
+}
+
+void insertion(Liste *liste, int x, int y)
+{
+    /* Création du nouvel élément */
+    Element *nouveau = malloc(sizeof(*nouveau));
+    if (liste == NULL || nouveau == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+    nouveau->x = x;
+    nouveau->y = y;
+
+    /* Insertion de l'élément au début de la liste */
+    nouveau->suivant = liste->premier;
+    liste->premier = nouveau;
+    liste->nbelements=liste->nbelements+1;
+}
+
+void afficherListe(Liste *liste)
+{
+    if (liste == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    Element *actuel = liste->premier;
+
+    while (actuel != NULL)
+    {
+        printf("combinaison x,y : %d  ,  %d \n", actuel->x,actuel->y);
+        actuel = actuel->suivant;
+    }
+}
+
+void suppression(Liste *liste)
+{
+    if (liste == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    if (liste->premier != NULL)
+    {
+        Element *aSupprimer = liste->premier;
+        liste->premier = liste->premier->suivant;
+        free(aSupprimer);
+    }
+}
+
+int abstete(Liste *liste){
+  
+  Element *actuel = liste->premier;
+  return actuel->x;
+  
+}
+
+int tailledelachaine(Liste *liste) {
+  
+  return liste->nbelements;
+  
+}
+
+
+int ordtete(Liste *liste) {
+ Element *actuel = liste->premier;
+ return actuel->y;
+}
+
+int abscul(Liste *liste) {
+ Element *actuel = liste->premier;
+ int i;
+ for(i=1;i<liste->nbelements;i++)
+    {
+        actuel = actuel->suivant;
+    }
+ return actuel->x; 
+}
+
+int ordcul(Liste *liste) {
+ Element *actuel = liste->premier;
+ int i;
+ for(i=1;i<liste->nbelements;i++)
+    {
+        actuel = actuel->suivant;
+    }
+ return actuel->y; 
+}
+
+
+void freelastbloc(Liste *liste) {
+  int i;
+  Element *actuel = liste->premier;
+  for(i=1; i<liste->nbelements-1; i++){
+    actuel = actuel->suivant;
+  }
+  Element *asupprimer = actuel->suivant;
+  free(asupprimer);
+  actuel->suivant = NULL;
+  liste->nbelements = liste->nbelements-1;
+}
+
+
+void freeListe(Liste *liste){
+  while(liste->premier!=NULL) suppression(liste);
+}
+
+
+
+
+
+
+
+
@@ -0,0 +1,45 @@
+typedef void *element_t;
+
+  typedef struct {
+  element_t *contenu;
+  int nombre;
+  int alloue;
+} liste_t;
+
+int taille(liste_t *l);
+int enfiler (liste_t *l,element_t e, int taille);
+int afficher (liste_t *l, void(*affichage)(element_t));
+int defiler(liste_t *l);
+element_t dernier(liste_t *l);
+element_t premier(liste_t *l);
+element_t enieme(int x, liste_t *l);
+
+
+
+typedef struct Element Element;
+struct Element
+{
+    int x;
+    int y;
+    Element *suivant;
+};
+
+
+typedef struct Liste Liste;
+struct Liste
+{
+    int nbelements;
+    Element *premier;
+};
+
+Liste *initialisation();
+void insertion(Liste *liste, int x, int y);
+void afficherListe(Liste *liste);
+void suppression(Liste *liste);
+int abstete(Liste *liste);
+int tailledelachaine(Liste *liste);
+int ordtete(Liste *liste);
+int abscul(Liste *liste);
+int ordcul(Liste *liste);
+void freelastbloc(Liste *liste);
+void freeListe(Liste *liste);
@@ -0,0 +1,45 @@
+typedef void *element_t;
+
+  typedef struct {
+  element_t *contenu;
+  int nombre;
+  int alloue;
+} liste_t;
+
+int taille(liste_t *l);
+int enfiler (liste_t *l,element_t e, int taille);
+int afficher (liste_t *l, void(*affichage)(element_t));
+int defiler(liste_t *l);
+element_t dernier(liste_t *l);
+element_t premier(liste_t *l);
+element_t enieme(int x, liste_t *l);
+
+
+
+typedef struct Element Element;
+struct Element
+{
+    int x;
+    int y;
+    Element *suivant;
+};
+
+
+typedef struct Liste Liste;
+struct Liste
+{
+    int nbelements;
+    Element *premier;
+};
+
+Liste *initialisation();
+void insertion(Liste *liste, int x, int y);
+void afficherListe(Liste *liste);
+void suppression(Liste *liste);
+int abstete(Liste *liste);
+int tailledelachaine(Liste *liste);
+int ordtete(Liste *liste);
+int abscul(Liste *liste);
+int ordcul(Liste *liste);
+void freelastbloc(Liste *liste);
+
@@ -0,0 +1,278 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* typedef struct Element Element;
+
+struct Element
+
+{
+
+    int nombre;
+
+    Element *suivant;
+
+};
+
+
+typedef struct Liste Liste;
+
+struct Liste
+
+{
+
+    Element *premier;
+
+};
+
+
+Liste *initialisation()
+{
+    Liste *liste = malloc(sizeof(*liste));
+    Element *element = malloc(sizeof(*element));
+
+    if (liste == NULL || element == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    element->nombre = 0;
+    element->suivant = NULL;
+    liste->premier = element;
+
+    return liste;
+}
+
+void insertion(Liste *liste, int nvNombre)
+{
+
+    Element *nouveau = malloc(sizeof(*nouveau));
+    if (liste == NULL || nouveau == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+    nouveau->nombre = nvNombre;
+
+   
+    nouveau->suivant = liste->premier;
+    liste->premier = nouveau;
+}
+
+void afficherListe(Liste *liste)
+{
+    if (liste == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    Element *actuel = liste->premier;
+
+    while (actuel != NULL)
+    {
+        printf("%d -> ", actuel->nombre);
+        actuel = actuel->suivant;
+    }
+    printf("NULL\n");
+}
+
+void suppression(Liste *liste)
+{
+    if (liste == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    if (liste->premier != NULL)
+    {
+        Element *aSupprimer = liste->premier;
+        liste->premier = liste->premier->suivant;
+        free(aSupprimer);
+    }
+} */
+
+typedef struct Element Element;
+
+struct Element
+
+{
+
+    //int nombre;
+    int x;
+    int y;
+    Element *suivant;
+
+};
+
+
+typedef struct Liste Liste;
+
+struct Liste
+
+{
+    int nbelements;
+    
+    Element *premier;
+
+};
+
+
+Liste *initialisation()
+{
+    Liste *liste = malloc(sizeof(*liste));
+    Element *element = malloc(sizeof(*element));
+
+    if (liste == NULL || element == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    //element->nombre = 0;
+    element->x =0;
+    element->y =0;
+    
+    element->suivant = NULL;
+    liste->premier = element;
+    liste->nbelements =0;
+
+    return liste;
+}
+
+void insertion(Liste *liste, int x, int y)
+{
+    /* Création du nouvel élément */
+    Element *nouveau = malloc(sizeof(*nouveau));
+    if (liste == NULL || nouveau == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+    nouveau->x = x;
+    nouveau->y = y;
+
+    /* Insertion de l'élément au début de la liste */
+    nouveau->suivant = liste->premier;
+    liste->premier = nouveau;
+    liste->nbelements=liste->nbelements+1;
+}
+
+void afficherListe(Liste *liste)
+{
+    if (liste == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    Element *actuel = liste->premier;
+
+    while (actuel != NULL)
+    {
+        printf("combinaison x,y : %d  ,  %d \n", actuel->x,actuel->y);
+        actuel = actuel->suivant;
+    }
+}
+
+void suppression(Liste *liste)
+{
+    if (liste == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    if (liste->premier != NULL)
+    {
+        Element *aSupprimer = liste->premier;
+        liste->premier = liste->premier->suivant;
+        free(aSupprimer);
+    }
+}
+
+int abstete(Liste *liste){
+  
+  Element *actuel = liste->premier;
+  return actuel->x;
+  
+}
+
+int tailledelachaine(Liste *liste) {
+  
+  return liste->nbelements;
+  
+}
+
+
+int ordtete(Liste *liste) {
+ Element *actuel = liste->premier;
+ return actuel->y;
+}
+
+int abscul(Liste *liste) {
+ Element *actuel = liste->premier;
+ int i;
+ for(i=1;i<liste->nbelements;i++)
+    {
+        actuel = actuel->suivant;
+    }
+ return actuel->x; 
+}
+
+int ordcul(Liste *liste) {
+ Element *actuel = liste->premier;
+ int i;
+ for(i=1;i<liste->nbelements;i++)
+    {
+        actuel = actuel->suivant;
+    }
+ return actuel->y; 
+}
+
+
+void freelastbloc(Liste *liste) {
+  int i;
+  Element *actuel = liste->premier;
+  for(i=1; i<liste->nbelements-1; i++){
+    actuel = actuel->suivant;
+  }
+  Element *asupprimer = actuel->suivant;
+  free(asupprimer);
+  actuel->suivant = NULL;
+  liste->nbelements = liste->nbelements-1;
+}
+
+void freeListe(Liste *liste){
+  while(liste->premier!=NULL) suppression(liste);
+}
+
+int main()
+
+{
+
+    Liste *maListe = initialisation();
+
+
+    insertion(maListe, 4 , 8);
+
+    insertion(maListe, 3 , 9);
+
+    insertion(maListe, 7 , 12);
+    
+    insertion(maListe, 10 , 15);
+    
+    printf("\n\n\n");
+    
+    int a = ordcul(maListe);
+    
+    printf("%d \n",a);
+
+    freelastbloc(maListe);
+    
+    afficherListe(maListe);
+
+    freeListe(maListe);
+
+	printf("\n ca va free");
+
+    afficherListe(maListe);
+
+printf("\n ca a free");
+    return 0;
+
+}
@@ -0,0 +1,275 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* typedef struct Element Element;
+
+struct Element
+
+{
+
+    int nombre;
+
+    Element *suivant;
+
+};
+
+
+typedef struct Liste Liste;
+
+struct Liste
+
+{
+
+    Element *premier;
+
+};
+
+
+Liste *initialisation()
+{
+    Liste *liste = malloc(sizeof(*liste));
+    Element *element = malloc(sizeof(*element));
+
+    if (liste == NULL || element == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    element->nombre = 0;
+    element->suivant = NULL;
+    liste->premier = element;
+
+    return liste;
+}
+
+void insertion(Liste *liste, int nvNombre)
+{
+
+    Element *nouveau = malloc(sizeof(*nouveau));
+    if (liste == NULL || nouveau == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+    nouveau->nombre = nvNombre;
+
+   
+    nouveau->suivant = liste->premier;
+    liste->premier = nouveau;
+}
+
+void afficherListe(Liste *liste)
+{
+    if (liste == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    Element *actuel = liste->premier;
+
+    while (actuel != NULL)
+    {
+        printf("%d -> ", actuel->nombre);
+        actuel = actuel->suivant;
+    }
+    printf("NULL\n");
+}
+
+void suppression(Liste *liste)
+{
+    if (liste == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    if (liste->premier != NULL)
+    {
+        Element *aSupprimer = liste->premier;
+        liste->premier = liste->premier->suivant;
+        free(aSupprimer);
+    }
+} */
+
+typedef struct Element Element;
+
+struct Element
+
+{
+
+    //int nombre;
+    int x;
+    int y;
+    Element *suivant;
+
+};
+
+
+typedef struct Liste Liste;
+
+struct Liste
+
+{
+    int nbelements;
+    
+    Element *premier;
+
+};
+
+
+Liste *initialisation()
+{
+    Liste *liste = malloc(sizeof(*liste));
+    Element *element = malloc(sizeof(*element));
+
+    if (liste == NULL || element == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    //element->nombre = 0;
+    element->x =0;
+    element->y =0;
+    
+    element->suivant = NULL;
+    liste->premier = element;
+    liste->nbelements =0;
+
+    return liste;
+}
+
+void insertion(Liste *liste, int x, int y)
+{
+    /* Création du nouvel élément */
+    Element *nouveau = malloc(sizeof(*nouveau));
+    if (liste == NULL || nouveau == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+    nouveau->x = x;
+    nouveau->y = y;
+
+    /* Insertion de l'élément au début de la liste */
+    nouveau->suivant = liste->premier;
+    liste->premier = nouveau;
+    liste->nbelements=liste->nbelements+1;
+}
+
+void afficherListe(Liste *liste)
+{
+    if (liste == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    Element *actuel = liste->premier;
+
+    while (actuel != NULL)
+    {
+        printf("combinaison x,y : %d  ,  %d \n", actuel->x,actuel->y);
+        actuel = actuel->suivant;
+    }
+}
+
+void suppression(Liste *liste)
+{
+    if (liste == NULL)
+    {
+        exit(EXIT_FAILURE);
+    }
+
+    if (liste->premier != NULL)
+    {
+        Element *aSupprimer = liste->premier;
+        liste->premier = liste->premier->suivant;
+        free(aSupprimer);
+    }
+}
+
+int abstete(Liste *liste){
+  
+  Element *actuel = liste->premier;
+  return actuel->x;
+  
+}
+
+int tailledelachaine(Liste *liste) {
+  
+  return liste->nbelements;
+  
+}
+
+
+int ordtete(Liste *liste) {
+ Element *actuel = liste->premier;
+ return actuel->y;
+}
+
+int abscul(Liste *liste) {
+ Element *actuel = liste->premier;
+ int i;
+ for(i=1;i<liste->nbelements;i++)
+    {
+        actuel = actuel->suivant;
+    }
+ return actuel->x; 
+}
+
+int ordcul(Liste *liste) {
+ Element *actuel = liste->premier;
+ int i;
+ for(i=1;i<liste->nbelements;i++)
+    {
+        actuel = actuel->suivant;
+    }
+ return actuel->y; 
+}
+
+
+void freelastbloc(Liste *liste) {
+  int i;
+  Element *actuel = liste->premier;
+  for(i=1; i<liste->nbelements-1; i++){
+    actuel = actuel->suivant;
+  }
+  Element *asupprimer = actuel->suivant;
+  free(asupprimer);
+  actuel->suivant = NULL;
+  liste->nbelements = liste->nbelements-1;
+}
+
+void freeListe(Liste *liste){
+  while(liste->premier!=NULL) suppression(liste);
+}
+
+
+int main()
+
+{
+
+    Liste *maListe = initialisation();
+
+
+    insertion(maListe, 4 , 8);
+
+    insertion(maListe, 3 , 9);
+
+    insertion(maListe, 7 , 12);
+    
+    insertion(maListe, 10 , 15);
+    
+    printf("\n\n\n");
+    
+    int a = ordcul(maListe);
+    
+    printf("%d \n",a);
+
+    freelastbloc(maListe);
+    
+    afficherListe(maListe);
+
+    freeListe(maListe);
+
+    afficherListe(maListe);
+    return 0;
+
+}
@@ -0,0 +1,24 @@
+REPERTOIRES = Graphique Liste Testliste Centipede
+COMPILE = $(REPERTOIRES:%=all-%)
+DEVERMINE = $(REPERTOIRES:%=debug-%)
+NETTOYAGE = $(REPERTOIRES:%=clean-%)
+export CFLAGS += -g -Wall 
+
+all: $(COMPILE)
+$(COMPILE):
+	$(MAKE) -C $(@:all-%=%)
+
+debug: $(DEVERMINE)
+$(DEVERMINE): CFLAGS += -g -DDEVERMINE
+$(DEVERMINE):
+	$(MAKE) -C $(@:debug-%=%)
+
+clean: $(NETTOYAGE)
+$(NETTOYAGE):
+	$(MAKE) -C $(@:clean-%=%) clean
+
+all-Main: all-Bibliotheque
+debug-Main: debug-Bibliotheque
+
+.PHONY: $(COMPILE) $(DEVERMINE) $(NETTOYAGE)
+.PHONY: all debug clean
@@ -0,0 +1,12 @@
+SOURCES = $(wildcard *.c)
+OBJETS = $(SOURCES:.c=.o)
+BIBLIOTHEQUES = -L ../Liste -lListe
+EXECUTABLE = projet
+CFLAGS += -Wall -I ../Liste
+
+all: $(EXECUTABLE)
+$(EXECUTABLE): $(OBJETS)
+	$(CC) -o $@ $^ $(BIBLIOTHEQUES)
+
+clean:
+	rm -rf $(EXECUTABLE) *.o
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "libFile.h"
+#include <string.h>
+
+
+int main(){
+  
+liste_t desnombres={NULL,0,0};
+
+int petit = 10;
+int moyen = 100;
+int grand = 1000;
+
+enfiler(&desnombres,&petit,sizeof(int));
+enfiler(&desnombres,&moyen,sizeof(int));
+enfiler(&desnombres,&grand,sizeof(int));
+enfiler(&desnombres,&petit,sizeof(int));
+
+//afficher(&desnombres,affichage);
+
+//defiler(&desnombres);
+
+//afficher(&desnombres,affichage);
+
+return 0;
+}