AHA! SERPENT, EN C TOUT COURT, AVEC EDITEUR DE NIVEAUX, ENNEMIS ET MODE D'EMPLOI...

/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                     Action Professionelle 2002:                     //
//                                                                     //
//                             SERPENT                                 //
//                                                                     //
//                     PERNES Olivier BTSIG1                           //
//                                                                     //
//                            "COMMUN.H"                               //
//                                                                     //
//                                                                     //
/////////////////////////////////////////////////////////////////////////

#include <conio.h>
#include <stdlib.h>
#include <time.h>
#include <stdio.h>




int taperdu;                  //J'suis mort ou pas?? (0 ou 1)
int score;                    //score en cours (0-9)


struct {                      //Structure du serpent:
 int x;                       // position en x du serpent
 int y;                       // position en y du serpent
 int dir;                     // direction du serpent
 int lgQueue;                 // longueur de la queue
 struct {                     // 'matrice' de queue:
  int x;                      //  coordonn,e en X
  int y;                      //  coordonn,e en Y
 }queue[42];                  //  42 elements max
}serpent;

struct {                      //Structure des balles:
 int x;                       // Position en X
 int y;                       // Position en Y
 int incx;                    // Incr,mentation en X
 int incy;                    // Incr,mentation en Y
}baballe[10];                 // 10 balles maximum

struct {                      //Structure des niveaux:
 int EnCours;                 // Index en cours de Liste
 int NbMax;                   // Total de niveaux
 int Liste[100];              // Liste des num,ros de niveaux
} Niveaux;

int MAT[43][80];              //Matrice repr,sentant l'ecran (1=mur,2=pomme)


void Message(char l1[74],char l2[74],char l3[74]);
void FaireNiveau();
void ObtenirNiveaux();
int  Editeur(int nivo);
void place_baballes();
void deplace_baballes();
int menu();





/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                     Action Professionelle 2002:                     //
//                                                                     //
//                             SERPENT                                 //
//                                                                     //
//                     PERNES Olivier BTSIG1                           //
//                                                                     //
//                            "EDITOR.C"                               //
//                                                                     //
//                                                                     //
/////////////////////////////////////////////////////////////////////////

#include "commun.h"



int Editeur(int nivo)
{
 char temp[64];         //Sert pour le nom de fichier lors de l'ecriture
 FILE *fichier;         //Pointeur vers le fichier a ouvrir
 int touche=0,fin=0;    //Quelle touche appuy,e?? Avons nous fini??
 int x,y;               //Variables utilis,es pour parcourir la matrice
 int curseurx,curseury; //Position du curseur

 curseurx=40;           //Place le curseur au milieu de l'ecran
 curseury=21;


  //Definition du nom de fichier en fonction du num,ro en argument
  sprintf(temp,"level%d.dat",nivo);

 if (__file_exists(temp)==0) //Detecte si le fichier existe deja
 {
 //Dans le cas ou le fichier n'existe pas:
 //'Dessine' les murs du jeu dans la matrice:
 //1)R,initialise cette derniere:
 for (x=0;x<=79;x++)
  for (y=0;y<=42;y++)
   MAT[y][x]=0;
 //2)'Trace' les bordures haute et basse
 for (x=0;x<=79;x++)
  {MAT[0][x]=1;  MAT[42][x]=1;}
 //3)'Trace' les bordures gauche et droite
 for (y=0;y<=42;y++)
  {MAT[y][0]=1;  MAT[y][79]=1;}

 }
 else {
 //Dans le cas ou le fichier existe, charger le niveau dans la matrice
 fichier = fopen(temp,"r");
 for (y=0;y<43;y++)        //43 lignes (0-42)
  for (x=0;x<81;x++)       //81 car 0-79 + 2 car. de retour ligne
   {
    touche=fgetc(fichier); //Stocke le caractere suivant dans touche
    if (touche>=48) MAT[y][x]=touche-48;  //>48 ascii = >0 (donc pas de retour
   }                                      //charriot ou autre car. systemes
  fclose(fichier);                        //Ferme le fichier
 }

 textattr((BLUE << 4) | WHITE); //Rend le fond de texte bleu et le txt blanc

 clrscr();



 while (!(fin==1)) {



 //Scanne la matrice pour y trouver des 1:
 for (x=0;x<=79;x++)
  for (y=0;y<=42;y++)
   {
    if (MAT[y][x]!=0)
    ScreenPutChar('Û', (BLUE << 4) | WHITE, x, y);//Trace les murs
   }

 //Affiche le curseur:
 if (MAT[curseury][curseurx]==0)
  ScreenPutChar('_', BLINK | (BLUE << 4) | LIGHTMAGENTA, curseurx,curseury);
 else
  //Si l'on est deja sur un mur, changer la couleur du mur.
  ScreenPutChar('Û', (BLUE << 4) | LIGHTMAGENTA,curseurx,curseury );


 while (!kbhit()); //Attendre une touche
  //Efface le curseur avant de repositionner le suivant
  ScreenPutChar(' ', (BLUE << 4), curseurx,curseury);
  touche=getch();  //Recupere le code ASCII de la touche

  if (touche==32)  //Si on appuie sur espace: inverser le statut du mur:
   MAT[curseury][curseurx] = !MAT[curseury][curseurx];// 0=absent et 1=present

  if (touche==27)  //Echap = Terminer
  {
   fin=1;
   break;
  }

  if (touche==0)               //0: touche ,tendue
   touche = getch();           //|->r,cuperer le code de la touche ,tendue
   
  switch(touche){
    case 'H':                  //haut
     if (curseury>1)
      curseury--;              //Monte le curseur
     break;
    case 'M':                  //droite
     if (curseurx<78)
     curseurx++;
     break;
    case 'P':                  //bas
     if (curseury<41)
     curseury++;
     break;
    case 'K':                  //gauche
     if (curseurx>1)
     curseurx--;
     break;
  }


 }

  //Demande la confirmation de l'enregistrement du fichier
  touche = -1;
  while ((touche <0)||(touche >1))
  {
  clrscr();
  Message("Editeur:","Voulez vous enregistrer???","(tapez 0 pour oui ou 1 pour non): ");
  ScreenSetCursor(45/2,57); //Place le curseur a la fin de la phrase
  scanf("%d",&touche);      //Saisie du chiffre
  }

  if (touche==0)
  {
  //Ecrit la matrice MAT dans le fichier...
  //ouvre le fichier en mode ,criture
   fichier=fopen(temp,"w");
   //Pour tous les elements de la matrice:
   for (y=0;y<43;y++)
    for (x=0;x<80;x++)
     {//2)v,rifier la matrice, en cas d'erreur, remplacer par un mur (1)
      if ((MAT[y][x]>1)||(MAT[y][x]<0)) MAT[y][x] = 1;
      //3)ecrire dans le fichier le caractere en cours
       fputc(MAT[y][x]+48,fichier);  // 0 + 48 = '0'et 1 + 48 = '1'
      if (x==79) fputc(10,fichier);}//Si on est en fin de ligne rajouter un
   fclose(fichier);                 //LineFeed
  }

return(0);
}



/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                     Action Professionelle 2002:                     //
//                                                                     //
//                             SERPENT                                 //
//                                                                     //
//                     PERNES Olivier BTSIG1                           //
//                                                                     //
//                            "LEVEL.C"                                //
//                                                                     //
//                                                                     //
/////////////////////////////////////////////////////////////////////////
#include <dir.h>
#include "commun.h"


/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                      FAIRENIVEAU: Lit le fichier de niveau, place   //
//                      les infos dans la matrice MAT, et affiche les  //
//                      murs.                                          //
//                                                                     //
/////////////////////////////////////////////////////////////////////////

void FaireNiveau()
{

 int x,y;
 int lettre;
 char tmp[50];
 FILE *fichier;
 strcpy(tmp,"level");      // "levelX.dat"
 strcat(tmp,itoa(Niveaux.Liste[Niveaux.EnCours],NULL,9));
 strcat(tmp,".dat");
 fichier = fopen(tmp,"r");
 for (y=0;y<43;y++)        //43 lignes (0-42)
  for (x=0;x<81;x++)       //81 car 0-79 + 2 car. de retour ligne
   {
    lettre=fgetc(fichier);
    if (lettre>=48) MAT[y][x]=lettre-48;  //>48 ascii = >0 (donc pas de retour
   }                                      //charriot ou autre car. systemes
  fclose(fichier);                        //Ferme le fichier

  for (y=0;y<43;y++)
   for (x=0;x<80;x++)
    if (MAT[y][x]==1)                     // Si on a un mur (1):
     ScreenPutChar('Û', WHITE, x, y);     // l'afficher

  return;
}

/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                      PLACEPOINT: Place al,atoirement le point a     //
//                      manger pour le serpent.                        //
//                                                                     //
/////////////////////////////////////////////////////////////////////////
void PlacePoint()
{
 int x,y;
 int good=0;
 while (!(good==1))
 {
  x = (random()%77)+1;                     //80-2 (pour les murs), soit de 0-77
  y = (random()%41)+1;                     //43-2 (pour les murs), soit de 0-41
  if (MAT[y][x]==0)                        //V,rifie que la place est libre
   {                                       //dans la matrice,
    MAT[y][x]=2;                           //et y place un 2 . cet endroit
    good=1;
   }
 }
 ScreenPutChar(48+score, GREEN | (BLUE<<4), x, y); // Afficher le point
}




/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                      MESSAGE:affiche une boite de dialogue          //
//                      avec trois lignes (l1,l2etl3)                  //
//                                                                     //
/////////////////////////////////////////////////////////////////////////

void Message(char l1[74],char l2[74],char l3[74])
{

 int lignes=0,nbCarac=0; //Nb de lignes et nb de caracteres
 int X=0,Y=0;            //Position de la fenetre
 char fnL1[78]={},fnL2[74]={},fnL3[74]={},fnL4[74]={},fnL5[74]={};
 int i=0;

  clrscr();
  //Redessine la matrice
  for (Y=0;Y<43;Y++)
   for (X=0;X<80;X++)
    {
    if (MAT[Y][X]==1) //Redessine les murs
     ScreenPutChar('Û', WHITE|(BLUE << 4), X, Y);
    if (MAT[Y][X]==2) //Redessine les points
     ScreenPutChar(48+score, BLINK|GREEN|(BLUE << 4), X, Y);
    if (MAT[Y][X]==3) //Redessine les balles
     ScreenPutChar('
', BLINK|RED|(BLUE << 4), X, Y);
    }
 
 //D,termine le nombre de caract¦res max a afficher et le nb de lignes
 if (strlen(l1)>0) lignes++;
 if (strlen(l2)>0) lignes++;
 if (strlen(l3)>0) lignes++;
 if ((strlen(l1)>=strlen(l2))&&((strlen(l1)>=strlen(l3)))) nbCarac=strlen(l1);
 if ((strlen(l2)>=strlen(l1))&&((strlen(l2)>=strlen(l3)))) nbCarac=strlen(l2);
 if ((strlen(l3)>=strlen(l1))&&((strlen(l3)>=strlen(l2)))) nbCarac=strlen(l3);

 //Determine la position de la fenetre selon les infos ci dessus (centree)
 X = (80 / 2) - (nbCarac+4)/2;
 Y = (43 / 2) - (lignes+2 )/2;

 //Genere la  fenetre ligne par ligne:
 //ligne 1 (que la bordure sup,rieure)
 strcpy(fnL1,"É");
 for (i=0;i<nbCarac+2;i++)
   strcat(fnL1,"Í");                  //remplit la ligne selon le nb de car max
 strcat(fnL1,"»");


 //Lignes 2-4 : en 3 parties :
 sprintf(fnL2,"Ý %s",l1);             //1)bordure gauche+texte de la ligne
 sprintf(fnL3,"Ý %s",l2);
 sprintf(fnL4,"Ý %s",l3);

 if (strlen(fnL2)<strlen(fnL1)-2)     //2)comble la fin de la ligne si besoin
  while(strlen(fnL2)<strlen(fnL1)-2)  //  par des espaces
    strcat(fnL2," ");
 strcat(fnL2," Þ");                   //3)bordure droite
 
 if (strlen(fnL3)<strlen(fnL1)-2)
  while(strlen(fnL3)<strlen(fnL1)-2)
    strcat(fnL3," ");
 strcat(fnL3," Þ");

 if (strlen(fnL4)<strlen(fnL1)-2)
  while(strlen(fnL4)<strlen(fnL1)-2)
    strcat(fnL4," ");
 strcat(fnL4," Þ");

 //Ligne Nø5 (bordure basse)
 strcpy(fnL5,"È");
 for (i=0;i<nbCarac+2;i++)
   strcat(fnL5,"Í");
 strcat(fnL5,"¼");

 //Affichage proprement dit de la bo¼te
 ScreenSetCursor(Y,X);
 printf("%s\n",fnL1);Y++;
 ScreenSetCursor(Y,X);
 if (strlen(l1)!=0) {printf("%s\n",fnL2);Y++;}
 ScreenSetCursor(Y,X);
 if (strlen(l2)!=0) {printf("%s\n",fnL3);Y++;}
 ScreenSetCursor(Y,X);
 if (strlen(l3)!=0) {printf("%s\n",fnL4);Y++;}
 ScreenSetCursor(Y,X);
 printf("%s\n",fnL5);

}

/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                      OBTENIRNIVEAUX:parcours le repertoire pour     //
//                      trouver les fichiers *.dat et en determiner le //
//                      nombre                                         //
//                                                                     //
/////////////////////////////////////////////////////////////////////////


void ObtenirNiveaux()
{
     struct ffblk f;
     char *tmp;
     int done = findfirst("*.dat", &f, FA_HIDDEN | FA_SYSTEM);//cherche les .dat
     tmp=f.ff_name + 5;  //Pointe vers le chiffre du nom de fichier,ex:"1.dat"
     while (!done)
     {
       Niveaux.Liste[Niveaux.NbMax] = atoi(tmp);//indexe le nø du niveau
       Niveaux.NbMax++;                         //incremente le nombre de niv.
       done = findnext(&f);                     //Cherche le .dat suivant
     }
     Niveaux.NbMax--;             //decremente le nombre max
     return;                      //(pour faire correspondre aux index)
}



/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                     Action Professionelle 2002:                     //
//                                                                     //
//                             SERPENT                                 //
//                                                                     //
//                     PERNES Olivier BTSIG1                           //
//                                                                     //
//                           "SERPENT.C"                               //
//                                                                     //
//                                                                     //
/////////////////////////////////////////////////////////////////////////

#include "commun.h"

const vitesse=50000;         //Vitesse du jeu
const HAUT=0,DROITE=1,BAS=2,GAUCHE=3;




/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                      INIT: initialise les variables                 //
//                                                                     //
/////////////////////////////////////////////////////////////////////////
void init()
{
 int i;
 score=0;
 taperdu=0;                   //ben oui, perdre des le debut c pas le but...
 srandom(time(NULL));         //initialise le g,n,rateur al,atoire
 serpent.x = 40;              //place le serpent en X au milieu de l'ecran
 serpent.y = 21;              //place le serpent en Y au milieu de l'ecran
 serpent.dir = random()%3;    //direction al,atoire: 0H,1D,2B,3G
 serpent.lgQueue=0;
 for (i=0;i<=48;i++)
  {serpent.queue[i].x = 40;   //initialise la queue
   serpent.queue[i].y = 21;}
 if (Niveaux.EnCours==0){
 Message("Bonjour!","Bienvenue dans SERPENT","Niveau 1: 3");
 sleep(1);
 Message("Bonjour!","Bienvenue dans SERPENT","Niveau 1: 2");
 sleep(1);
 Message("Bonjour!","Bienvenue dans SERPENT","Niveau 1: 1");
 sleep(1);
 clrscr();                       //efface le message
 ObtenirNiveaux();               //charge la liste de niveaux
 }
 FaireNiveau();                  //trace le niveau
 PlacePoint();                   //Place le point a attraper
 place_baballes();               //Place les balles
}

/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                      TOUCHE: Se charge de la gestion du score avec  //
//                      les points, et d,clenche le changement         //
//                      de tableau                                     //
//                                                                     //
/////////////////////////////////////////////////////////////////////////

void Touche()
{
 char temp[74];

 score++;                //incr,mente le score

 if (serpent.lgQueue!=0) //augmente la taille de la queue
  serpent.lgQueue = serpent.lgQueue + (serpent.lgQueue/2);
 else
  serpent.lgQueue=2;

 if (score==10)          //passe le niveau
 {
  Niveaux.EnCours++;     //incr,mente le num,ro du niveau
  if (Niveaux.EnCours>Niveaux.NbMax) //teste si il y a encore un niveau
   {
    Message("Bravo!!","vous avez gagn,","!!!");
    getkey();
    taperdu=1;
    return;
   }
  sprintf(temp,"Niveau %d: 3",Niveaux.EnCours+1);
  Message("","Bravo!!",temp);
  sleep(1);
  sprintf(temp,"Niveau %d: 2",Niveaux.EnCours+1);
  Message("","Bravo!!",temp);
  sleep(1);
  sprintf(temp,"Niveau %d: 1",Niveaux.EnCours+1);
  Message("","Bravo!!",temp);
  sleep(1);
  clrscr();
  init();                                //R,initialise les donn,es

 }
 else
 PlacePoint();                           //Replace un point

}




/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                      GAMEOVER: Comme son nom l'indique              //
//                                                                     //
/////////////////////////////////////////////////////////////////////////
void gameover()
 {
  int x,y;
  textattr( (BLUE << 4) | WHITE);
  Message ("Vous avez perdu","votre score:",itoa(score,NULL,9));
  taperdu = 1;
  while(!kbhit());
  return;
 }

/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                      GESTIONDEPCOL: Gere le deplacement du serpent  //
//                      et teste les collisions...                     //
//                                                                     //
/////////////////////////////////////////////////////////////////////////

void GestionDepCol()
{
    //Ralentit le jeu de 'vitesse'æs
    usleep(vitesse);
                                            //Gestion du dep. vers le haut
    if (serpent.dir == HAUT)
     {
      if (MAT[serpent.y-1][serpent.x]==0)
       serpent.y--;                         //deplace le serpent
      else if (MAT[serpent.y-1][serpent.x]==2)
        {Touche();serpent.y--;}             //Attrap, un point
       else taperdu=1;                      //touch, un mur
     }
    if (serpent.dir == DROITE)              //Gestion du dep. vers la droite
     {
      if (MAT[serpent.y][serpent.x+1]==0)
       serpent.x++;
      else if (MAT[serpent.y][serpent.x+1]==2)
        {Touche();serpent.x++;}
       else taperdu=1;
     }
    if (serpent.dir == BAS)                 //Gestion du dep. vers le bas
     {
      if (MAT[serpent.y+1][serpent.x]==0)
       serpent.y++;
      else if (MAT[serpent.y+1][serpent.x]==2)
        {Touche();serpent.y++;}
       else taperdu=1;
     }
    if (serpent.dir == GAUCHE)              //Gestion du dep. vers la gauche
     {
      if (MAT[serpent.y][serpent.x-1]==0)
       serpent.x--;
      else if (MAT[serpent.y][serpent.x-1]==2)
        {Touche();serpent.x--;}
       else taperdu=1;
     }


    return;
}

/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                      GEREQUEUE: Gere le mouvement de la queue       //
//                      g,r, en LILO (last in last out)                //
//                                                                     //
/////////////////////////////////////////////////////////////////////////
void GereQueue()
{
 int i;
 //efface le dernier element de la liste de l',cran
 ScreenPutChar('Û',BLUE,serpent.queue[serpent.lgQueue].x
                       ,serpent.queue[serpent.lgQueue].y);

 //remet a 0 dans la matrice le bout de queue effac,e
 MAT[serpent.queue[serpent.lgQueue].y][serpent.queue[serpent.lgQueue].x]=0;

 //D,cale tous les ,l,ments de la queue
 for (i=42;i>0;i--)
  {
  serpent.queue[i].x = serpent.queue[i-1].x;
  serpent.queue[i].y = serpent.queue[i-1].y;
  }

 //Ins¦re dans le haut de la pile la nouvelle coord. du serpent.
 serpent.queue[0].x = serpent.x;
 serpent.queue[0].y = serpent.y;

 //Met . jour la matrice
 for (i=0;i<=serpent.lgQueue;i++)
  MAT[serpent.queue[i].y][serpent.queue[i].x]=1;
 

}

/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                      MAIN: Routine principale                       //
//                                                                     //
/////////////////////////////////////////////////////////////////////////

main(int argc,char *argv[])
{
 int retour_menu=0;            //Variable contenant le nøde menu selectionne
 char Touche=0;                //Touche contient la touche appuy,e

 _set_screen_lines(43);        //Mode d'ecran:80*43 Texte


while (retour_menu!=2)
{
 retour_menu = menu();         //Affiche et gere le menu
 if (retour_menu < 0)
  {
  Editeur(abs(retour_menu));
  break;
  }

 if (retour_menu==0)
 {
  init();                       //initialise les variables

 

  while(taperdu!=1)             //Tant qu'on appuie pas sur echap...
  {
   while(!kbhit())              //Tant qu'on appuie sur rien...
    {
     GestionDepCol();           //Apelle la fonction de dep./collision
     GereQueue();               //Gere le deplacement de la queue
     deplace_baballes();
     if (taperdu==1) gameover();//Teste la mort (?!)
     ScreenPutChar('Û',WHITE,serpent.x,serpent.y); //Affiche le serpent
    }
    Touche=getch();             //Les touches 'normales' renvoient un code
                                //ascii standard (sur un caractere).
    if (Touche==0)              //Ascii 0==> touche ,tendue utilis,e...
     Touche=getch();            //Ce 2nd getch est pour r,cup,rer les touches

    switch (Touche)             //(codees sur 2 caract¦res (0+code))
    {
     case 27:                   //Echap = byebye
      taperdu = 1;
     case 'H':                  //le haut
      serpent.dir=HAUT;
      break;
     case 'M':                  //la droite
      serpent.dir=DROITE;
      break;
     case 'P':                  //le bas
      serpent.dir=BAS;
      break;
     case 'K':                  //la gauche
      serpent.dir=GAUCHE;
      break;
    }

   }
  }
 }
 return(0);

}






/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                     Action Professionelle 2002:                     //
//                                                                     //
//                             SERPENT                                 //
//                                                                     //
//                     PERNES Olivier BTSIG1                           //
//                                                                     //
//                            "BALLES.C"                               //
//                                                                     //
//                                                                     //
/////////////////////////////////////////////////////////////////////////


#include "commun.h"

const maxbaballes = 5;               //Determine le nombre de balles



/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                      PLACE_BALLE: Se charge de placer les balles    //
//                      dans la matrice et de les afficher             //
//                      (phase d'initialisation des balles)            //
//                                                                     //
/////////////////////////////////////////////////////////////////////////
void place_baballes()
{
 int i,fini;
 for (i=0;i<maxbaballes;i++)           //Pour toutes les balles:
 {
  fini = 0;                            //Tant qu'on a pas trouve une place
  while (fini==0)                      //libre dans la matrice
  {
   baballe[i].x = (random()%77)+1;     //Coordonn,es X et Y al,atoires
   baballe[i].y = (random()%41)+1;     // de 1-78 X et 1-24 Y

   baballe[i].incx = (random()%2)-1;   //Incrementation en X,Y al,atoires
   baballe[i].incy = (random()%2)-1;   // de -1 . 1
   if (baballe[i].incx == baballe[i].incy)
    if (baballe[i].incx == 0)          //Fait en sorte qu'une balle ne soit
     baballe[i].incx = 1;              //pas immobile (incx=incy=0)
   if (baballe[i].incx != 0)           //Mouvements diagonales d,sactiv,s
    if (baballe[i].incy != 0)
     baballe[i].incy = 0;

   if (MAT[baballe[i].y][baballe[i].x]==0)
   {                                   //Si la place est libre dans la matrice
    MAT[baballe[i].y][baballe[i].x]=3; //placer a ces coordonnees un 3
    fini = 1;
   }
  }
 //Affiche les balles
 ScreenPutChar('', LIGHTRED | (BLUE<<4), baballe[i].x, baballe[i].y);
 }
}

/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                      DEPLACE_BALLE: Se charge de d,placer les balles//
//                      dans la matrice et de les afficher             //
//                                                                     //
/////////////////////////////////////////////////////////////////////////

void deplace_baballes()
{
 int i,j;
 //Pour toutes les balles
 for (i=0;i<maxbaballes;i++)
 {
  if (baballe[i].x+baballe[i].incx == serpent.queue[0].x)
   if (baballe[i].y+baballe[i].incy == serpent.queue[0].y)
    taperdu=1;//Si les prochaines coord. de la balle= position de la tete
              //du serpent, alors on a perdu!!

  //SI la prochaine coordonn,e de la balle est pratiquable dans la matrice:
  if (MAT[baballe[i].y+baballe[i].incy][baballe[i].x+baballe[i].incx]==0)
  {
   if ((baballe[i].x+baballe[i].incx)>(78-abs(baballe[i].incx))||
       (baballe[i].x+baballe[i].incx)<(1+abs(baballe[i].incx)))
   {//Si on sort pas de l'ecran en X
    baballe[i].incx = -baballe[i].incx;//on inverse l'incrementation X
   }
   if ((baballe[i].y+baballe[i].incy)>(41-abs(baballe[i].incy))||
       (baballe[i].y+baballe[i].incy)<(1+abs(baballe[i].incy)))
   {//Si on sort pas de l'ecran en Y
    baballe[i].incy = -baballe[i].incy;//on inverse l'incrementation Y
   }
  }
  else
  {//Sinon c qu'on a un mur ou le serpent ou une balle ou un point a cet endroit
   //Si la balle se deplace verticalement uniquement
   if (baballe[i].incx == 0)
    baballe[i].incy = -baballe[i].incy; //on inverse l'incrementation Y
  baballe[i].incx = -baballe[i].incx;   //on inverse l'incrementation Y
  }
  //RAZ du pt de la matrice a l'ancienne position de la balle
  MAT[baballe[i].y][baballe[i].x]=0;
  //Efface la balle de l'ecran
  ScreenPutChar(' ', LIGHTRED | (BLUE<<4), baballe[i].x, baballe[i].y);
  //Met a jour en X et Y les coordonn,es de la balle
  baballe[i].x = baballe[i].x + baballe[i].incx;
  baballe[i].y = baballe[i].y + baballe[i].incy;
  //Place la balle dans la matrice (en y mettant un 3)
  MAT[baballe[i].y][baballe[i].x]=3;
  //et Affiche a l'ecran la balle
  ScreenPutChar('', LIGHTRED | (BLUE<<4), baballe[i].x, baballe[i].y);
 }
}
  



/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                     Action Professionelle 2002:                     //
//                                                                     //
//                             SERPENT                                 //
//                                                                     //
//                     PERNES Olivier BTSIG1                           //
//                                                                     //
//                             "MENU.C"                                //
//                                                                     //
//                                                                     //
/////////////////////////////////////////////////////////////////////////



#include "commun.h"


/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                   TRACE_FOND : remplit l'ecran d'un caractere pour  //
//                   simuler un 'beau' fond d'ecran pour le menu       //
//                                                                     //
/////////////////////////////////////////////////////////////////////////

void trace_fond()
{
 int x,y;
 //Pour dessiner sur fond bleu:
 textattr(BLUE<<4);
 //On efface l'ecran
 clrscr();
 //Pour tous les caract¦res de l'ecran:
 for(x=0;x<80;x++)
  for(y=0;y<43;y++)
   //Afficher ce caractere en gris sombre
   ScreenPutChar('²', DARKGRAY | (BLUE << 4), x, y);
}

/////////////////////////////////////////////////////////////////////////
//                                                                     //
//                   MENU: Affiche et gere le menu                     //
//                                                                     //
/////////////////////////////////////////////////////////////////////////

int menu()
{
 int x,y;
 int choix=0;
 int finmenu = 0;
 int touche=0;

 //Dessine le fond d'ecran
 trace_fond();

 while (finmenu == 0) //Tant que l'on a pas fini avec le menu
 {
  //Affiche le menu:
  ScreenPutString("ÛÛÛÛÛÛÛÛÛÛÛÛÛ", WHITE | (BLUE << 4), 34, 20);
  ScreenPutString("Û   JOUER   Û", WHITE | (BLUE << 4), 34, 21);
  ScreenPutString("Û  EDITEUR  Û", WHITE | (BLUE << 4), 34, 22);
  ScreenPutString("Û  A PROPOS Û", WHITE | (BLUE << 4), 34, 23);
  ScreenPutString("Û  QUITTER  Û", WHITE | (BLUE << 4), 34, 24);
  ScreenPutString("ÛÛÛÛÛÛÛÛÛÛÛÛÛ", WHITE | (BLUE << 4), 34, 25);
  //Selon le choix (choix MOD 4), on affiche dans une couleur differente
  switch(abs(choix) % 4){
   case 0:
    ScreenPutString("   JOUER   ", WHITE | (YELLOW << 4), 35, 21);
    break;
   case 1:
    ScreenPutString("  EDITEUR  ", WHITE | (YELLOW << 4), 35, 22);
    break;
   case 2:
    ScreenPutString("  A PROPOS ", WHITE | (YELLOW << 4), 35, 23);
    break;
   case 3:
    ScreenPutString("  QUITTER  ", WHITE | (YELLOW << 4), 35, 24);
    break;}
  //Attend la prochaine touche
  touche = getch();
  if (touche==0) touche=getch(); //Si l'on a une touche ,tendue
  switch (touche){          //Selon la touche:
   case 'H':                //Si c le haut:
    choix--;                //on d,cr,mente l'index du menu
    if (choix<0) choix = 3; //Evite que le menu se d,roule dans le sens
    break;                  // inverse lorsque l'on monte apres 'jouer'
   case 'P':
    choix++;                //Si c le haut, simple incrementation de l'index
    break;
   case 13:                 //Si l'on appuie sur entree:
    textattr((BLUE<<4)|WHITE);   //change les couleurs (bleu derriere,blanc
    clrscr();                    //devant), et applique en effacant l'ecran.
    //Mise a zero de la matrice
    for (x=0;x<80;x++)
     for (y=0;y<43;y++)
      MAT[y][x] = 0;
    //Selon le num,ro de menu:
    switch(abs(choix)%4){
     case 1:             //EDITEUR:
      Message("Editeur:","Veuillez entrer le num,ro","du niveau a editer:");
      ScreenSetCursor(45/2,48);
      scanf("%d",&touche);
      return -touche;
      break;
     case 2:            //A PROPOS:
      Message("SERPENT:","AP BTSIG Nø1","2002 PERNES Olivier   (opernes@wanadoo.fr)");
      getkey();
      trace_fond();
      break;
     case 3:            //QUITTER:
      Message("Merci d'avoir jou, a SERPENT","(ok le nom n'est pas original)","Au Revoir!!!!!");
      getkey();
      return 2;
      break;
     case !2:           //Quitte le menu sauf si on a fait a propos
      return(0);
      finmenu=1;
      break;
     }
  }
 }


}