Jeu du serpent en langage c

Soyez le premier à donner votre avis sur cette source.

Vue 30 952 fois - Téléchargée 4 709 fois

Description

Salut c'est ma première source ici. Je code depuis peu( septembre à l'esgi ), mais je n'ai absolument rien contre le critiques pour avancer ;)

J'ai essayé au maximum d'être clair dans mon code, et surtout simple.

S'il mes commentaires ne sont pas clair, ou qu'il ya des propositions, corrections, je suis à l'écoute ;)

Merci à tous

Source / Exemple :


/*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;
}

Conclusion :


voila, le jeu fonctionne avec devcpp. Pour borland, je suppose qu'il faut remplacer conio.c, par conio.h

Pour MVC++ je ne sais pas trop .. :(

Je travaille à rendre le jeu un peu plus fonctionnel ( choix des couleurs, possibilité de reprendre partie, pause ) et prépare une version avec la lib C++ SDL

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Pour un début, c'est vraiment parfait. :)

Personnellement, je suis en train d'apprendre un langage, le C++, et je suis impressionné par tes capacités ! ^-^
slt a tous j'aurais besoin du code du jeu twixt en c
suis nouveau dans la programmation et j'arrive meme pas a demarrer
> lamdah
jai vraiment besoin de votre je n'ai que 8 jours pour realiser cela..
merci d'avance...
Messages postés
305
Date d'inscription
jeudi 29 avril 2004
Statut
Membre
Dernière intervention
18 janvier 2012

reaction a _setcursortype(_NOCURSOR);
"_NOCURSOR undeclared" ;-P

y'a ptet qqchose a déclarer
Messages postés
6
Date d'inscription
dimanche 9 février 2003
Statut
Membre
Dernière intervention
31 décembre 2003

salut juste un petit conseil tu devrait faire disparaître le curseur qui suit le serpent sa fait bizarre je c'est qu'il existe cette fonction.

#include <conio.h>
_setcursortype(_NOCURSOR);
Afficher les 12 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.