JEU DU SERPENT EN LANGAGE C

/*gabarit.c*/

#include <conio.c>
#define HD 187
#define BD 188
#define HG 201
#define BG 200
#define HB 205
#define VB 186

void creergabarit(char texte[],int x, int y, int couleur_t, int couleur_c)
{
    int i = 0;
    while(texte[i++]);i--;
    gotoxy(x,y);
    textcolor(couleur_c);
    cprintf("%c",HG);while(i--)cprintf("%c",HB);cprintf("%c",187);
    gotoxy(x,y+1);
    cprintf("%c",VB);
    textcolor(couleur_t);
    cprintf("%s",texte);
    textcolor(couleur_c);
    cprintf("%c",VB);
    i = 0;
    while(texte[i++]);i--;
    gotoxy(x,y+2);
    cprintf("%c",BG);
    while(i--) cprintf("%c",HB);cprintf("%c",BD);
}






/*serpent.c*/
----------------------------------------------------------------------------------------------

#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <time.h>
#include "gabarit.c"
#define FALSE 0
#define TRUE 1

/*structure du serpent*/

typedef struct{
     int pos_x[200];/*tableau des coordonées en absicce des elements*/
     int pos_y[200];/* tableau des coordonnées en ordonnées des elements*/
     int direction; /*la direction ou va le serpent*/
     int vitesse;
     int score;
     int tete_x;    /*la position de la tete en x*/
     int old_tail_x;  /*la position de la queue en x*/
     int old_tail_y; /*et en y*/
     int tete_y;     /* tete y*/
     int sens;
     int largeur;
     char nom[10];
}serpent;

/*structure pomme*/

typedef struct{
    int x;
    int y;
    int type;
}pomme;


/*nos énumérations*/
enum{Largeur_Stade = 78,Hauteur_Stade = 20};
enum{Couleur_Bordure = 3,Couleur_Stade = 2,Couleur_Serpent = LIGHTRED,Forme_Tete=178,Forme_Corps=219};
enum{DROITE,GAUCHE,BAS,HAUT};
enum{LEFT=75,RIGHT=77,DOWN=80,UP=72};
enum{ESC=27,F1=59,F2,F3};

/*menu encore tres basique */

void menu(serpent *x)
{
    char buffer[10];
    int i = 0;
    int vitesse;
    clrscr();
    creergabarit("Choix de la vitesse",15,3,2,3);
    creergabarit("votre Nom",20,6,2,3);
    do{gotoxy(36,7);gets(buffer);}while(buffer[0]=='\0');
    for(;i<strlen(buffer)+1;i++)
    x->nom[i] = buffer[i];
    do{gotoxy(40,4);scanf("%d",&vitesse);}while(vitesse>6 || vitesse <0);
    x->vitesse = vitesse;
    fflush(stdin);getchar();
   
}

/*prcocédure remplissant le tableau stade*/

void init_stade(int stade[Hauteur_Stade][Largeur_Stade])
{
    int x,y;
    for(x=1;x<Hauteur_Stade;x++)
        for(y=1;y<Largeur_Stade;y++)
        stade[x][y]=0;
}

/*procédure l'affichant*/
void affiche_stade(int stade[Hauteur_Stade][Largeur_Stade])
{
    void init_stade(int [][]);
    int i,j;
    init_stade(stade);
    for(i=1;i<=Hauteur_Stade;i++)
        for(j=1;j<=Largeur_Stade;j++)
        {
        gotoxy(j,i);
        if(i==1 || i==Hauteur_Stade || j==1 || j==Largeur_Stade)
            textcolor(Couleur_Bordure);
        else 
            textcolor(Couleur_Stade);      
        cprintf("%c",177);
        }
}


/*fonction retournant VRAI ou FAUX, selon si la pomme et en contact avec le serpent*/
int test_pomme_snake(int x1,int y1,int x2,int y2)
{
    return x1==x2 && y1==y2;
}

/*procdure initialisant le serpent*/

void init_serpent(serpent* x)
{   
    int i = 0;
    x->direction = DROITE;
    x->sens = DROITE;
    x->vitesse = 3;
    x->largeur = 5;
    x->score = 0;
    for(;i<200;i++)
    {
        x->pos_x[i] = -1;
        x->pos_y[i] = -1;
    }
    for(i=0;i<x->largeur;i++)
    {
        x->pos_x[i] = 20 + i;
        x->pos_y[i] = 10; 
    }
    x->tete_x=x->pos_x[x->largeur-1];
    x->tete_y = 10;
    x->old_tail_x = x->pos_x[0];
    x->old_tail_y = x->pos_y[0];
}


/*Affichage des stats du joueur, tel les points,, la position de la tête, la longueur*/
void affiche_stat(serpent x)
{
creergabarit("score",1,22,2,3);gotoxy(10,23);cprintf("%d",x.score);
creergabarit("x_",18,22,2,3);gotoxy(24,23);cprintf("%2d",x.tete_x);
creergabarit("y_",30,22,2,3);gotoxy(34,23);cprintf("%2d",x.tete_y);
creergabarit("l_",45,22,2,3);gotoxy(49,23);cprintf("%2d",x.largeur);
}



/*procédure affichant le serpent*/
void display_serpent(serpent x)
{
    int l;
    for(l=0;l<x.largeur;l++)
    {
        gotoxy(x.pos_x[l],x.pos_y[l]);
        textcolor(LIGHTRED);
        if(l==x.largeur - 1)
        cprintf("%c",Forme_Tete);
        else cprintf("%c",Forme_Corps);
    }
}




/*procédure plaçant aléatoirement les pommes sur le terrain*/
void make_pomme(pomme *t,serpent x)
{
    static int flag = 0;
    int i =0;
    time_t v_time;
    if(!flag){time(&v_time);srand(v_time);flag++;}
    t->x = rand()%76 + 2;
    t->y = rand()%17 + 2;
    for(;i<x.largeur;i++){
    if(x.pos_x[i] == t->x) t->x++;
    if(x.pos_y[i] == t->y) t->y++;}
    if(t->x >=Largeur_Stade || t->x <= 0)t->x= Largeur_Stade/2;
    if(t->y >=Hauteur_Stade || t->y <= 0)t->y= 15;
    gotoxy(t->x,t->y);textcolor(WHITE);cprintf("%c",177);
    
}


/*procédure d'aggrandissement du serpent dans le cas ou une pomme a été mangée*/
void add_item(serpent *x)
{
    int i = 0;
    int flag = 0;
    
    for(i=x->largeur;i>=0;i--)
    {
        x->pos_x[i+1] = x->pos_x[i];
        x->pos_y[i+1] = x->pos_y[i];
    }
    if(x->direction == DROITE)
    {
          if(x->pos_x[1]>x->pos_x[2])
            {
               x->pos_x[0] = x->pos_x[1]+1;
               x->pos_y[0] = x->pos_y[1];
            }
        else 
           {
               x->pos_x[0] = x->pos_x[1]-1;
               x->pos_y[0] = x->pos_y[1];
           }
    }
    if(x->direction == GAUCHE)
    {
         if(x->pos_x[1]>x->pos_x[2])
            {
               x->pos_x[0] = x->pos_x[1]-1;
               x->pos_y[0] = x->pos_y[1];
            }
        else 
           {
               x->pos_x[0] = x->pos_x[1]-1;
               x->pos_y[0] = x->pos_y[1];
           }
    }
    if(x->direction == HAUT)
    {
        x->pos_x[0] = x->pos_x[1];
        x->pos_y[0] = x->pos_y[1]+1;
    }
    if(x->direction == BAS)
    {
        x->pos_x[0] = x->pos_x[1];
        x->pos_y[0] = x->pos_y[1]-1;
    }
    /*on réinitialise la longueur du serpent*/
    x->largeur++;
    /*on reinitialise les coordonnéesde la queue*/
    x->old_tail_x = x->pos_x[0];
    x->old_tail_y = x->pos_y[0];
   
}


/*procédure de sauvegarde, encore à faire, de manière a pouvoir reprendre la partie*/
void save(serpent *x, pomme *t)
{
FILE *fp;
int i;
char filename[21];
gets(filename);
fp = fopen(filename,"wb");
fwrite(x,sizeof(serpent),1,fp);
fwrite(t,sizeof(pomme),1,fp);
fclose(fp);
cprintf("Operation reussi");
getchar();
clrscr();

}

/*enregistrement des scores*/

void get_score(serpent x)
{
    FILE *fp;
    char *buffer;
    void save(serpent *,pomme *t);
    char d;
    int i = 0;
    puts("Entrez le nom du fichier pour sauvegarder votre score");
    buffer = (char*)malloc(sizeof(char));
    while((d=getchar())!='\n')
    {
        buffer[i++]=d;
        buffer = (char*)realloc(buffer,(i+1)*sizeof(char));
    }
    buffer[i] = '\0';
    fp = fopen(buffer,"w");
    fprintf(fp,"%s\n",x.nom);
    fprintf(fp,"%d",x.score);
    fclose(fp);
    fprintf(stdout,"operation reussie");
    free(buffer);
    getchar();
}

/*fonctions retournant FAUX si le serpent ne s'est pas encastré dans lui même, Vrai sinon*/

int test_pos(serpent x)
{
    int i = 0;
    for(;i< x.largeur-1;i++)
    {
        if(x.tete_x == x.pos_x[i] && x.tete_y == x.pos_y[i])return 1;
    }
    return 0;
}
    

/*procédure principale du jeu*/

void maj(serpent *x,pomme*t)
{   
    int i = 0; /*compteur*/
  
    FILE *fp; /*pour enregistrer les scores*/
    int stade[Hauteur_Stade][Largeur_Stade];
    void make_pomme(pomme *,serpent);
    int booleen = FALSE;
    int test_pos(serpent x);
    void add_item(serpent *);
    int test_pomme_snake(int,int,int,int);
    char c;
    
    init_stade(stade);
    affiche_stade(stade);
    /*tant que le serpent n'est pas rentré dans le mur .....*/
        while( x->tete_x != 1 && x->tete_x != Largeur_Stade && x->tete_y != 1 && x->tete_y != Hauteur_Stade)
        {    
                 
                affiche_stat(*x); /*on affiche tout d'abord les statistiques à l'aide de notre procédure*/
                if(booleen == FALSE) /*S'il n'ya pas de pomme*/
                {
                make_pomme(t,*x); /*On en crée une*/
                booleen = TRUE;    /*on met a Vrai notre flag*/
                }
                
                /*si notre serpent touche la pomme, on met notre flag a faux pour dire qu'il n'ya plus de pomme sur le terrain, on incremente le score, on aggrandit le serpent*/
                if(test_pomme_snake(x->tete_x,x->tete_y,t->x,t->y)){x->score+=3;booleen=FALSE; add_item(x); }
                /*teste la direction, et modifie la position de la tête*/
                if(x->direction == DROITE)
                x->tete_x++;
                if(x->direction == GAUCHE)
                x->tete_x--;
                if(x->direction == HAUT)
                x->tete_y--;
                if(x->direction == BAS)
                x->tete_y++;
                
                /*on parcourt nos tableau de position*/
                for(i=0;i<x->largeur;i++)
                {    
                	/*si l'index du tableau correspond a l'ancienne tête*/            
                    if(i==x->largeur-1)
                    {
                    x->pos_x[i]=x->tete_x;
                    x->pos_y[i]=x->tete_y;
                    }
                    /*sinon la position de l'element precdent prend celle du suivant*/
                    else
                    {
                    x->pos_x[i] = x->pos_x[i+1];
                    x->pos_y[i] = x->pos_y[i+1];
                    }
                }
                /*si le serpent se rentre dedans, on arrête le jeu et on sort de la boucle*/
                if(test_pos(*x)==1){clrscr();cprintf("loose\n");system("pause");break;}
                /*autrement, on efface la queue*/
                gotoxy(x->old_tail_x,x->old_tail_y);textcolor(Couleur_Stade);cprintf("%c",177);x->old_tail_x=x->pos_x[0];x->old_tail_y=x->pos_y[0]; /*efface la queue */
                /*temporisation de la vitesse*/
                sleep(x->vitesse*30);
                /*réaffichage du serpent*/
                display_serpent(*x);
                /*si une touche a été pressé*/
                if(kbhit())
                {          
                		  /*si il s'agit du pavé directionnel*/	      
                          if((c=getch())==-32)
                          {
                          c= getch();
                          /*on modifie le membre direction de notre srepent en conséquence*/
                          switch(c)
                           {
                            case UP: if (x->direction != BAS)
                                        x->direction = HAUT;
                                        break;
                            case DOWN: if (x->direction != HAUT)
                                        x->direction = BAS;
                                        break;
                            case RIGHT: if (x->direction != GAUCHE) 
                                        x->direction = DROITE;
                                         break;
                            case LEFT: if (x->direction != DROITE) 
                                        x->direction = GAUCHE; 
                                        break;
                           }  
                           }
                           /*s'il s'agit d'une autre touche étendue*/
                           else if(c==0)
                           {
                           c=getch();
                           /*on accomplit d'autre actions, q'uil me reste a travailler*/
                           switch(c)
                           {
                           case F1:clrscr();
                           cprintf("Enregistrez sous ...");
                           save(x,t);
                           affiche_stade(stade);
                           break;
                           default:exit(1);
                           }
                           }
                } 
                                     
}
/*quand on est sorti du jeu, on peut sauvegarder nitre score*/
clrscr();
gotoxy(10,10);
cprintf("Outch.....   ");
get_score(*x);getchar();

}



int main()
{
char c;
serpent x;
pomme t;
do{
menu(&x);
init_serpent(&x);
maj(&x,&t);
clrscr();
fflush(stdin);
cprintf("rejouer?? ((o)ui, non )");
c = getchar();
}while(c=='o' ||c == 'O');

getchar();
return 0;
}