Brique game Realisé par Xtreen
- Realiser pour maitriser les fontionnalités
- de la librairie SDL et aussi avancé sur cette librairie avec votre aide en me corrigeant
Source / Exemple :
/** Brique game Realisé par Xtreen
- dennière mise à jour 19/03/2013 à 21:25:58
- Realiser pour maitriser les fontionnalitées
- de la librairie SDL
*
*
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_image.h>
#include <assert.h>
#define TESTER(valeur, mot); assert(valeur!=NULL);
#define REPAIRE_X 218
#define REPAIRE_Y 79
#define COTE_BRICK 20
#define NBRE_BRICKS_HAUT 18
#define NBRE_BRICKS_LARG 11
#define LARGEUR_ECRAN 500
#define HAUTEUR_ECRAN 500
#define ECRAN_ACCEUIL "image\\Ecran_D.bmp"
#define ECRAN_JEU "image\\jeu.bmp"
#define FONT "police\\fun.ttf"
#define BAS_PIED "image\\bas.bmp"
#define APPUIE " Appuiez sur "
#define QUIT "Echap pour quitter"
#define TAILLE ((NBRE_BRICKS_HAUT*NBRE_BRICKS_LARG)+5)
#define FORMES 18
enum Direction
{
BAS, GAUCHE , DROITE
};
enum Forme
{
BATON_D, BATON_C,
CUBE,
L_NORMAL_D, L_INVERSE_D,L_NORMAL_G,L_INVERSE_G,
L_COUCHER_GN,L_COUCHER_DN,L_COUCHER_GI, L_COUCHER_DI,
TROIS_N, TROIS_I, TROIS_G, TROIS_D,
N_NORMAL_G, N_NORMAL_D,
Z_NORMAL,Z_INVERSE
};
// Declaration des fonctions
int Jeux(SDL_Surface *ecran);
void Welcome(SDL_Surface *ecran);
int Graphique(SDL_Surface **ecran ,SDL_Surface **rectangle, SDL_Rect *mouvement,int lime,SDL_Surface **cube_M, SDL_Surface **cube_A);
int Pause (SDL_Surface **surface);
int Gravitation (SDL_Rect *disposi, SDL_Rect *mouve);
void Deplacement(SDL_Rect *disposition, SDL_Rect *mouvement, int direction);
int Limite(SDL_Rect *disposition, SDL_Rect *mouvement,int direction);
void Genere_brick(SDL_Rect *mouvement,int forme);
void Brick_depot(SDL_Rect *position, SDL_Rect *disposition);
int Game_over(SDL_Surface **ecran, SDL_Rect *mouve, SDL_Rect *dispo);
int Supprim_ligne(SDL_Rect *dispo);
void Ecrire(SDL_Surface **tab, char* lettre);
void Rotation( SDL_Rect *mouve);
int main ( int argc, char** argv )
{
SDL_Surface *screen=NULL,*icon=NULL;
if( SDL_Init(SDL_INIT_VIDEO)==0 && SDL_Init(SDL_INIT_TIMER)==0)
{
screen=SDL_SetVideoMode(LARGEUR_ECRAN,HAUTEUR_ECRAN,32,SDL_HWSURFACE);
TESTER(screen,"ecran")
SDL_WM_SetCaption("Xtreen Game",NULL);
icon=IMG_Load("image/icon.png");
TESTER(icon,"icone")
/// SDL_WM_SetIcon(icon,NULL);
Welcome(screen);
SDL_FreeSurface(screen);
IMG_Quit();
SDL_Quit();
}
else
{
fprintf(stderr,"Impossible d'initialiser Sdl %s ", SDL_GetError());
}
return EXIT_SUCCESS;
}
int Gravitation (SDL_Rect *disposi, SDL_Rect *mouve)//pour creer l'effet de la Gravitation
{
int i;
if(Limite(disposi,mouve,BAS)==0)
{
for (i=0;i<4;i++)
mouve[i].y+=COTE_BRICK;
}
return EXIT_SUCCESS;
}
void Deplacement(SDL_Rect *disposition, SDL_Rect *mouvement, int direction)///Pour deplasser les Briques
{
int k=0;
if(direction==GAUCHE && Limite(disposition,mouvement,direction)==0)
{
for (k=0;k<4;k++)
mouvement[k].x -=COTE_BRICK;
}
if(direction==DROITE&& Limite(disposition,mouvement,direction)==0)
{
for (k=0;k<4;k++)
mouvement[k].x+=COTE_BRICK;
}
if(direction==BAS && Limite(disposition,mouvement,direction)==0)
{
for(k=0;k<4;k++)
mouvement[k].y+=COTE_BRICK;
}
}
void Genere_brick(SDL_Rect *mouvement,int forme)// Genere les briques
{
int i[4]={0},j[4]={0},k=0;
int g=mouvement[0].x/COTE_BRICK, h=mouvement[0].y/COTE_BRICK;
if(forme==CUBE)// on dessine la forme d'un Cube
{
i[0]=g;
i[1]=g;
i[2]=g+1;
i[3]=g+1;
j[0]=h;
j[1]=h+1;
j[2]=h;
j[3]=h+1;
}
if(forme==BATON_D)// dessine la forme d'un baton debout
{
i[0]= i[1]=i[2]=i[3]=g;
j[0]=h;
j[1]=j[0]+1;
j[2]=j[1]+1;
j[3]=j[2]+1;
}
if(forme==BATON_C)
{
i[1]=g+1;
i[2]=g+2;
i[3]=g+3;
i[0]=g;
j[0]=j[1]=j[2]=j[3]=h;
}
if(forme==L_NORMAL_D)
{
i[1]=i[2]=i[0]=g;
i[3]=g+1;
j[0]=h;
j[1]=h+1;
j[2]=h+2;
j[3]=h+2;
}
if(forme==L_INVERSE_D)
{
i[0]=g;
i[1]=g+1;
i[3]=g;
i[2]=g;
j[0]=h;
j[1]=h;
j[2]=h+1;
j[3]=h+2;
}
if(forme==L_NORMAL_G)
{
i[0]=i[1]=i[2]= g;
i[3]=g+1;
j[1]=h+1;
j[0]=h;
j[2]=j[3]=h+2;
}
if(forme==L_INVERSE_G)
{
i[0]=g;
i[1]=g+1;
i[2]=g+1;
i[3]=g+1;
j[0]=j[1]=h;
j[2]=h+1;
j[3]=h+2;
}
if(forme==L_COUCHER_DN)
{
i[0]=i[1]=g;
i[2]=g+1;
i[3]=g+2;
j[0]=h;
j[1]=j[2]=j[3]=h+1;
}
if(forme==L_COUCHER_DI)
{
i[0]=i[1]=g;
i[2]=g+1;
i[3]=g+2;
j[0]=j[2]=j[3]=h;
j[1]=h+1;
}
if(forme==L_COUCHER_GI)
{
i[0]=g;
i[1]=g+1;
i[2]=i[3]=g+2;
j[1]=j[2]=j[0]=h;
j[3]=h+1;
}
if(forme==L_COUCHER_GN)
{
i[0]=g;
i[1]=g+1;
i[2]=i[3]=g+2;
j[0]=j[1]=j[2]=h;
j[3]=h-1;
}
if(forme==TROIS_D)
{
i[0]=i[1]=i[3]=g;
i[2]=g+1;
j[0]=h;
j[1]=j[2]=h+1;
j[3]=h+2;
}
if(forme==TROIS_I)
{
i[0]=g;
i[1]=i[2]=g+1;
i[3]=g+2;
j[0]=j[1]=j[3]=h;
j[2]=h+1;
}
if(forme==TROIS_N)
{
i[0]=g;
i[1]=g-1;
i[2]=g;
i[3]=g+1;
j[0]=h;
j[1]=j[2]=j[3]=h+1;
}
if(forme==TROIS_G)
{
i[0]=i[1]=i[3]=g;
i[2]=g-1;
j[0]=h;
j[1]=j[2]=h+1;
j[3]=h+2;
}
if(forme==Z_NORMAL)
{
i[0]=i[2]=g;
i[1]=g -1;
i[3]=g+1;
j[0]=j[1]=h;
j[2]=j[3]=h+1;
}
if(forme==Z_INVERSE)
{
i[0]=i[2]=g;
i[3]=g -1;
i[1]=g+1;
j[0]=j[1]=h;
j[2]=j[3]=h+1;
}
if(forme==N_NORMAL_D)
{
i[0]=i[1]=g;
i[2]=i[3]=g+1;
j[0]=h;
j[1]=j[2]=h+1;
j[3]=h+2;
}
if(forme==N_NORMAL_G)
{
i[0]=i[1]=g;
i[2]=i[3]=g-1;
j[0]=h;
j[1]=j[2]=h+1;
j[3]=h+2;
}
for (k=0;k<4;k++)
{
mouvement[k].x=COTE_BRICK*(i[k]);
mouvement[k].y=COTE_BRICK*(j[k]);
}
mouvement[4].x=forme;
}
void Rotation( SDL_Rect *mouve)
{
switch(mouve[4].x)
{
case CUBE:
break;
case L_NORMAL_D:
Genere_brick(mouve,L_COUCHER_DI);
break;
case L_COUCHER_DI:
Genere_brick(mouve,L_INVERSE_G);
break;
case L_INVERSE_G:
Genere_brick(mouve,L_COUCHER_GN);
break;
case L_COUCHER_GN:
Genere_brick(mouve,L_NORMAL_D);
break;
case L_NORMAL_G:
Genere_brick(mouve,L_COUCHER_DN);
break;
case L_COUCHER_DN:
Genere_brick(mouve,L_INVERSE_D);
break;
case L_INVERSE_D:
Genere_brick(mouve,L_COUCHER_GI);
break;
case L_COUCHER_GI:
Genere_brick(mouve,L_NORMAL_G);
break;
case BATON_C:
Genere_brick(mouve,BATON_D);
break;
case BATON_D:
Genere_brick(mouve,BATON_C);
break;
case TROIS_D:
Genere_brick(mouve,TROIS_I);
break;
case TROIS_I:
Genere_brick(mouve,TROIS_G);
break;
case TROIS_G:
Genere_brick(mouve,TROIS_N);
break;
case TROIS_N:
Genere_brick(mouve,TROIS_D);
break;
case N_NORMAL_D:
Genere_brick(mouve,Z_INVERSE);
break;
case Z_INVERSE:
Genere_brick(mouve,N_NORMAL_D);
break;
case N_NORMAL_G:
Genere_brick(mouve,Z_NORMAL);
break;
case Z_NORMAL:
Genere_brick(mouve,N_NORMAL_G);
break;
default:
Genere_brick(mouve,CUBE);
break;
}
}
int Limite(SDL_Rect *disposition, SDL_Rect *mouvement,int direction)
{
int resultat=0,i,j;
if(direction==BAS)
for(i=0;i<4;i++)
{
if((mouvement[i].y+COTE_BRICK)>(COTE_BRICK*(NBRE_BRICKS_HAUT-1)))
resultat=1;
for(j=0;j<200;j++)
{
if((disposition[j].x)==(mouvement[i].x)&&(disposition[j].y)==(mouvement[i].y+COTE_BRICK))
resultat=1;
}
}
if(direction==DROITE)
for(i=0;i<4;i++)
{
if((mouvement[i].x +COTE_BRICK)>(COTE_BRICK*(NBRE_BRICKS_LARG-1)))
resultat=1;
for(j=0;j<200;j++)
{
if((disposition[j].x)==(mouvement[i].x+COTE_BRICK)&&(disposition[j].y)==(mouvement[i].y))
resultat=1;
}
}
if(direction==GAUCHE)
for(i=0;i<4;i++)
{
if((mouvement[i].x-COTE_BRICK)<0)
resultat=1;
for(j=0;j<200;j++)
{
if((disposition[j].x)==(mouvement[i].x-COTE_BRICK)&&(disposition[j].y)==(mouvement[i].y))
resultat=1;
}
}
return resultat;
}
int Graphique(SDL_Surface **ecran ,SDL_Surface **rectangle, SDL_Rect *mouvement,int lime,SDL_Surface **cube_M, SDL_Surface **cube_A)
{
static SDL_Rect attente[4];
int k=0,i;
static int genere=1,vb=0;
srand(time(NULL));
if(vb==0)
{
for(i=0;i<4;i++)
{
attente[i].x=4*COTE_BRICK;
attente[i].y=COTE_BRICK;
}
Genere_brick(attente,(rand() % FORMES));
vb++;
}
if(genere==1)
{
for( k=0;k<=4;k++)
{
mouvement[k].x=attente[k].x;
mouvement[k].y=attente[k].y;
}
Genere_brick(attente,(rand()%FORMES));
genere=0;
}
genere=lime;
for (k=0;k<4;k++)
{
SDL_BlitSurface(*cube_M,NULL,*rectangle,&mouvement[k]);
SDL_BlitSurface(*cube_A,NULL,*ecran,&attente[k]);
}
return EXIT_SUCCESS;
}
int Jeux(SDL_Surface *ecran)
{
SDL_Surface *fond_jeux1=NULL, *fond_deroulement=NULL, *pied=NULL, *cube_R=NULL, *point=NULL, *level=NULL, *cube_M=NULL, *cube_A=NULL;
clock_t heure=0, heurA=0;
SDL_Rect cadre,position,fond,disposition[TAILLE],detail[2],stock[4];
SDL_Rect mouvement[5];
int i;
cadre.x=REPAIRE_X;
cadre.y=REPAIRE_Y;
position.x=0;
position.y=0;
for(i=0;i<4;i++)
{
mouvement[i].x=0;
mouvement[i].y=0;
}
for(i=0;i<TAILLE;i++)
{
disposition[i].x=0;
disposition[i].y=0;
}
fond.x=0;
fond.y=450;
int arreter=1, lime=0,compteur=0, change=0;
int vitesse=2, d=0;
detail[1].x=COTE_BRICK;//les coordonées des ecritures ceci concerne l'affichage des points
detail[1].y=COTE_BRICK*9;
detail[0].x=COTE_BRICK;// concerne l'affichage de la vitesse
detail[0].y=COTE_BRICK*15;
SDL_Event eventPol;
cube_M=IMG_Load("image\\cube_b.png");
cube_A=IMG_Load("image\\cube_be.png");
cube_R=IMG_Load("image\\cube_v.png");
fond_jeux1=SDL_LoadBMP(ECRAN_JEU);
pied=SDL_LoadBMP(BAS_PIED);
TESTER(cube_A,"cube a")
TESTER(cube_M,"Cube_M")
TESTER(cube_R,"cube r")
TESTER(pied,"NULL");
TESTER(fond_jeux1,"NULL")
fond_deroulement=SDL_CreateRGBSurface(SDL_HWSURFACE,(NBRE_BRICKS_LARG*COTE_BRICK),(NBRE_BRICKS_HAUT*COTE_BRICK),32,0,0,0,0);
TESTER(fond_deroulement,"NULL")
SDL_EnableKeyRepeat(200,50);
SDL_FillRect(fond_deroulement,NULL,SDL_MapRGB(ecran->format,255,125,255));
char name[10]="";
sprintf(name," %d ",compteur*10);
Ecrire(&point,name);
char vites[10]="";
sprintf(vites," %d G ",vitesse);
Ecrire(&level,vites);
while(arreter)
{
heurA=clock();
SDL_Delay(100);
SDL_PollEvent(&eventPol);
SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,0,0,0));/// on efface l'ecran
SDL_BlitSurface(fond_jeux1,NULL,ecran,&position);/// on dessine le fond de jeu
SDL_BlitSurface(pied,NULL,ecran,&fond);
lime=0;
if((heurA-(1000-(vitesse*vitesse*9)))>(heure))
///creer la gravitation par Seconde
{
if(Limite(disposition,mouvement,BAS)==1)///SI LA BRIQUE TOMBE AU FOND
{
lime=1;
TESTER(level,"level")
Brick_depot(mouvement,disposition);
//permet de stocker les brique au fond
compteur+=Supprim_ligne(disposition);/// verifi si une ligne est pleine afin d'incrémenté le score
if(compteur!=change)/// nous indique que le score à changé
{
sprintf(name," %d ",compteur*10); /// NOMBRE DE POINTS
Ecrire(&point,name);
sprintf(vites," %d G ",vitesse);
Ecrire(&level,vites);
change=compteur;
}
}
Gravitation(disposition,mouvement);
//pour creer l'effet gravitationel
heure=heurA;
}
SDL_FillRect(fond_deroulement,NULL,SDL_MapRGB(ecran->format,255,220,255));
Graphique(&ecran,&fond_deroulement,mouvement,lime,&cube_M,&cube_A);
for(i=0;i<TAILLE;i++)
{
// on dessine les careaux qui sont au repos;
if(disposition[i].y !=0 )
SDL_BlitSurface(cube_R,NULL,fond_deroulement,&disposition[i]);
}
SDL_BlitSurface(fond_deroulement,NULL,ecran,&cadre);
SDL_BlitSurface(point,NULL,ecran,&detail[1]);
SDL_BlitSurface(level,NULL,ecran,&detail[0]);
// Dessine le point et la vitesse
arreter=Game_over(&ecran,mouvement,disposition);// voir si le jeu est fini
//maitenant, la verification des touches
if(eventPol.type==SDL_QUIT||eventPol.key.keysym.sym==SDLK_ESCAPE)
{
arreter=0;
}
if(eventPol.type==SDL_KEYDOWN)/// si on a appuier sur une touche
{
if (eventPol.key.keysym.sym==SDLK_LEFT)
{
Deplacement(disposition,mouvement, GAUCHE);
}
if(eventPol.key.keysym.sym==SDLK_RIGHT)
{
Deplacement(disposition,mouvement, DROITE);
}
if(eventPol.key.keysym.sym==SDLK_DOWN)
{
Gravitation(disposition,mouvement);
Deplacement(disposition,mouvement,BAS);
}
if(eventPol.key.keysym.sym==SDLK_UP)
{
for(d=0;d<4;d++)
{
stock[d].x=mouvement[d].x;
stock[d].y=mouvement[d].y;
}
Rotation(mouvement);//on efectue la rotation
if(Limite(disposition,mouvement,BAS)!=0)//et on limites les bugs
{
for(d=0;d<4;d++)
{
mouvement[d].x= stock[d].x;
mouvement[d].y=stock[d].y;
}
}
}
if (eventPol.key.keysym.sym==SDLK_SPACE)
{
arreter=Pause(&ecran);
}
}
if((eventPol.active.state & SDL_APPINPUTFOCUS) ==SDL_APPINPUTFOCUS)
{
arreter= Pause(&ecran);
}
SDL_Flip(ecran);
}
SDL_FreeSurface(fond_deroulement);
SDL_FreeSurface(pied);
SDL_FreeSurface(fond_jeux1);
SDL_FreeSurface(cube_A);
SDL_FreeSurface(cube_M);
SDL_FreeSurface(cube_R);
return EXIT_SUCCESS;
}
void Welcome(SDL_Surface *ecran)
{
SDL_Surface *Ecran_Acceuil=NULL;
SDL_Event evenement;
SDL_Rect position;
position.x=0;
position.y=0;
int arreter=1;
Ecran_Acceuil=SDL_LoadBMP(ECRAN_ACCEUIL);
TESTER(Ecran_Acceuil,"NULL")
SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,0,0,0));
SDL_BlitSurface(Ecran_Acceuil,NULL,ecran,&position);
while(arreter)
{
SDL_Flip(ecran);
SDL_WaitEvent(&evenement);
if(evenement.type==SDL_QUIT||evenement.key.keysym.sym==SDLK_ESCAPE)
{
arreter=0;
}
if(evenement.key.keysym.sym==SDLK_RETURN)
{
Jeux(ecran);
arreter=0;
}
SDL_Flip(ecran);
}
SDL_FreeSurface(Ecran_Acceuil);
}
void Ecrire(SDL_Surface **tab, char* lettre)/// pour ecrire du texte
{
if(TTF_Init() !=-1)
{
SDL_Color brown={128,0,128};
TTF_Font *police=TTF_OpenFont(FONT,40);
TESTER(police,"police")
- tab=TTF_RenderText_Blended(police,lettre,brown);
TTF_CloseFont(police);
TTF_Quit();
}
else
{
fprintf(stderr," Erreur de chargement %s ",TTF_GetError());
}
}
int Pause (SDL_Surface **surface)//fonction Pour mettre en pause
{
int i=1,j=1;
SDL_Event stoper;
SDL_Surface *indice=NULL,*pied=NULL,*transparence=NULL;
SDL_Rect centre,bas,debut;
indice=IMG_Load("image\\pause.png");
pied=SDL_LoadBMP("image\\bas3.bmp");
transparence=SDL_LoadBMP("image\\noir.bmp");
TESTER(indice,"NULL")
TESTER(pied,"NULL")
TESTER(transparence,"transparence")
centre.x=((*surface)->w/2)-(indice->w/2);
centre.y=((*surface)->h/2)-(indice->h/2);
bas.x=0;
bas.y=(*surface)->h - pied->h;
debut.x=0;
debut.y=0;
SDL_SetAlpha(transparence,SDL_SRCALPHA,128);
SDL_BlitSurface(transparence,NULL,*surface,&debut);
SDL_BlitSurface(pied,NULL,*surface,&bas);
SDL_Flip(*surface);
while(i)
{
SDL_WaitEvent(&stoper);
SDL_BlitSurface(indice,NULL,*surface,¢re);
SDL_Flip(*surface);
if(stoper.type==SDL_QUIT||stoper.key.keysym.sym==SDLK_ESCAPE)
{
i=0;
j=0;
}
if(stoper.key.keysym.sym==SDLK_RETURN)
i=0;
}
SDL_FreeSurface(indice);
SDL_FreeSurface(transparence);
SDL_FreeSurface(pied);
return j;
}
void Brick_depot(SDL_Rect *position, SDL_Rect *disposition)
{
int i=0,j;
for(j=0;i<4;j++)
{
if(disposition[j].y==0)
{
disposition[j].x = position[i].x;
disposition[j].y = position[i].y;
i++;
}
}
}
int Game_over(SDL_Surface **ecran , SDL_Rect *mouve, SDL_Rect *dispo)
{
int k=1,l=1,j,i;
for(j=0;j<4;j++)
for( i=0;i<TAILLE;i++)
if((dispo[i].y==COTE_BRICK&&dispo[i].y==mouve[i].y))
{
SDL_Surface *g_over=NULL,*bas=NULL, *transparent=NULL;
SDL_Rect position,cadre,debut;
g_over=IMG_Load("image\\over.png");
bas=IMG_Load("image\\bas5.bmp");
transparent=SDL_LoadBMP("image\\noir.bmp");
SDL_SetAlpha(transparent,SDL_SRCALPHA,128);
TESTER(bas,"NULL");
TESTER(g_over,"NULL");
cadre.x=0;
cadre.y=500- bas->h;
position.x= 250 -(g_over->w/2);
position.y=250 - (g_over->h/2);
debut.x=0;
debut.y=0;
SDL_Event waite;
SDL_BlitSurface(transparent,NULL,*ecran,&debut);
while(k)
{
SDL_BlitSurface(g_over,NULL,*ecran,&position);
SDL_BlitSurface(bas,NULL,*ecran,&cadre);
SDL_Flip(*ecran);
SDL_WaitEvent(&waite);
if(waite.type==SDL_QUIT||waite.key.keysym.sym==SDLK_ESCAPE)
{
k=0;
l=0;
}
}
SDL_FreeSurface(g_over);
SDL_FreeSurface(bas);
SDL_FreeSurface(transparent);
}
return l;
}
int Supprim_ligne(SDL_Rect *dispo)
{
int gagne=0,valeur[NBRE_BRICKS_HAUT]={0},i=0,j,k,b=0;
for(i=NBRE_BRICKS_HAUT;i>0;i--)
{
for(j=0;j<TAILLE;j++)
{
if(dispo[j].y==i*COTE_BRICK)
valeur[i]++;
}
}
for(i=0;i<=18;i++)
{
if(valeur[i]==NBRE_BRICKS_LARG)
{
gagne++;
for(k=0;k<TAILLE;k++)
{
if (dispo[k].y==i*COTE_BRICK)//supprime la ligne pleine
{
dispo[k].x=0;
dispo[k].y=0;
}
}
for(k=0;k<TAILLE;k++)
{/// permet de remplire la ligne vide
if (dispo[k].y<i*COTE_BRICK && dispo[k].y !=0)
dispo[k].y +=COTE_BRICK;
}
for(b=i;b>=0;b--)//on rectifie les valeurs de la variable valeur
{
if(i==0)
valeur[0]=0;
else
valeur[i]=valeur[i-1];
}
}
}
return pow(gagne,2);
}
Conclusion :
J'attends vos remarques.
Tout est possible
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.