#ifndef CONSTANTES_H_INCLUDED
#define CONSTANTES_H_INCLUDED

#define TAILLE_BLOCK 30
#define BOARDPOS 0
#define NB_BLOCK_LARG 10
#define NB_BLOCK_HAUT 20
#define NEXT_X 245
#define NEXT_Y 120
#define NB_SKIN 3
#define NB_TUNE 5

enum {RIEN,BAS,DROITE,GAUCHE,ROT_D,ROT_G};//liste des mouvements
enum {TE,EL,LE,CARRE,BARRE,ESS,ZED};//liste des pièces
enum {ACT,PREV};

struct S_piece
{//definition de la structure d'une piece.
    int type;//forme de la piece
    int orientation;//orientation de la piece 0,90,180 ou 270°
    SDL_Surface *carre;//pointeur vers le set de skin qui compose la pièce
    SDL_Rect decoup;//position de découpe dans le skin set.
    SDL_Rect pos[4];//position des 4 éléments de la piece.
};

struct S_input
{//définition de la structure d'acquisition des entrées.
    bool key[SDLK_LAST];//ensemble des touches
    bool padBt[2][2];//boutons [mémoire][bouton du pad]
    bool padHat[2][8];//chapeaux [mémoire][index du chapeau]
    bool mseBt[8];//boutons de souris
    bool quit;//evenement "croix"
    unsigned int padRepet;//valeur de répetition (pour le chapeau du pad)
    unsigned int padRepetActTime;//valeur actuelle pour calcul du repeat chapeau
    unsigned int btRepet;//valeur de répétition des boutons
    unsigned int btRepetActTime;//valeur actuelle pour le calcul du repet bt
};

struct S_infos
{//structure d'infos générale
    bool fullscreen;//mode fullscreen on/off
    int modeJoueur;//mode de jeu
    int vitesse;//vitesse du jeu (difficultée)
    int hauteur;//hauteur de départ
    int skin;//type de skin
    int tune;//music
};

struct S_score
{//structure des scores
    int actBest;//meilleur score du moment
    char score[10][20];//tableau de char des scores
};

struct S_control
{//structure des moyens de control

    SDL_Joystick* *joy;//tableau de pointeurs vers les pads branchés
    int modeControl;//mode de control 0:clavier; 1:pad
    int numPad;//index du pad utilisé
    int padBtDroite;//bouton du pad pour rotation droite
    int padBtGauche;//bouton du pad pour rotation gauche
    int clavierDroite;//touche clavier pour rotation droite
    int clavierGauche;//touche clavier pour rotation gauche
};

struct S_global
{//structure globale contenant les pointeurs vers les autres structures
    S_input *Sinput;
    S_infos *Sinfos;
    S_score *Sscore;
    S_control *Scontrol;
};

struct S_temp
{//structure temporaire
    int padNum;
    int skinNum;
    int tuneNum;
    int control;
    int btDroit;
    int btGauc;
    int clavDroit;
    int clavGauc;
};


#endif // CONSTANTES_H_INCLUDED

#ifndef JEU_H_INCLUDED
#define JEU_H_INCLUDED

//le jeu.
int jeu(SDL_Surface *ecran, S_global *Sglobal);
#endif // JEU_H_INCLUDED

#ifndef INPUTS_H_INCLUDED
#define INPUTS_H_INCLUDED

//init e la structure des entrées.
void init_input(struct S_input* Sinput);

//capture des entrées.
void get_input(struct S_global *Sglobal);

//capture des controles.
int saisie_cfg(SDL_Surface *ecran,S_temp *Stemp);

#endif // INPUTS_H_INCLUDED

#ifndef JEU_FNCTNS_H_INCLUDED
#define JEU_FNCTNS_H_INCLUDED

//initialisation des pieces.
void init_piece(S_piece *Spiece,SDL_Surface *bloc,const int forme);

//test de faisabilité du mouvement.
int test_Mvt(S_piece *Spiece, const bool tableau[NB_BLOCK_LARG][NB_BLOCK_HAUT],const int direction);

//déplacement de la piece.
void bouger(SDL_Surface *ecran, S_piece *Spiece, int direction);

//fixer la piece dans la matrice.
int fixer(S_piece *Spiece, bool tableau[NB_BLOCK_LARG][NB_BLOCK_HAUT]);

//test des lignes pleines.
int test_ligne (bool tableau[NB_BLOCK_LARG][NB_BLOCK_HAUT]);

//suppression et décalage des lignes.
void decalage(SDL_Surface *ecran, bool tableau[NB_BLOCK_LARG][NB_BLOCK_HAUT], int ligne);

//affichage de la piece suivante.
void disp_next(SDL_Surface *ecran, S_piece *Spiece);

//affichage de texte
void disp_texte(SDL_Surface *ecran, char texte[], TTF_Font* police, SDL_Rect* position);

//animation Game over
void game_over(SDL_Surface* ecran, TTF_Font *police);

#endif // JEU_FNCTNS_H_INCLUDED

#ifndef MENU_H_INCLUDED
#define MENU_H_INCLUDED

int menu_principal (SDL_Surface *ecran, S_global *Sglobal);

int menu_scores (SDL_Surface *ecran, S_global *Sglobal);

int menu_options (SDL_Surface *ecran, S_global *Sglobal);

int menu_best(SDL_Surface *ecran,S_global *Sglobal,int score);

#endif // MENU_H_INCLUDED

#ifndef FICHIER_H_INCLUDED
#define FICHIER_H_INCLUDED

//initialisation de la structure maitre
void init_global(S_global *Sglobal);

//libération de la mémoire allouée
void libere_global_mem(S_global *Sglobal);

//initialisation de la structure d'infos
void init_infos(S_infos *Sinfos);

//initialisation de la structure de control
void init_control(S_control *Scontrol);

//lecture du fichier des controls
int lire_control(struct S_global *Sglobal);

//ecriture du fichier des controls
int ecrire_control(struct S_global *Sglobal);

//lecture du fichier des scores
int lire_score(struct S_score *Sscore);

//ecriture du fichier des scores
int ecrire_score(struct S_score *Sscore);

//initialisation des scores
int init_score(struct S_score *Sscore);

//attribution des pads branchés
void pad_set (S_control *control);

//libération des pads branchés
void pad_reset (S_control *Scontrol);

//aide au placement du curseur dans le fichier
int placerCurs(FILE *fichier, int ligne);

//placement du score
int compare_score(int score, S_score *Sscore);

//convertion char en int
int char_to_int(const char text[]);

//placer le nouveau record
void save_record(S_score *Sscore,char nom[],int rank,int score);

//passage plein encran
void switch_screen(SDL_Surface *ecran,S_global *Sglobal);

//transformation des erreurs FSOUND en text
char *FSOUND_Err(int valeur);

#endif // FICHIER_H_INCLUDED

#include <iostream>
#include <SDL/SDL.h>
#include <SDL/fmod.h>
#include <SDL/SDL_ttf.h>
#include "constantes.h"
#include "inputs.h"
#include "jeu.h"
#include "fichier.h"
#include "menu.h"


int main ( int argc, char** argv )
{//**** VALIDE ****
    (void) argc;
    (void) argv;

    /***** Déclaration variables et initialisation*****/

    bool fin=false;//maintien de boucle.


    //initialisation de la SDL.
    if ( SDL_Init( SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK) < 0 )
    {//gestion d'erreur
        printf( "MAIN / Err init SDL: %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }


    //création de l'icone de fenetre.
    SDL_WM_SetIcon(SDL_LoadBMP("pics/icone.bmp"),NULL);


    //initialisation de TTF.
    if (TTF_Init()<0)
    {//gestion de l'erreur.
        printf("JEU / Err init TTF:%s\n",TTF_GetError());
        exit(EXIT_FAILURE);
    }


    //intitialisation de FSOUND.
    if (FSOUND_Init(44100,32,0)<0)
    {//Gestion de l'erreur.
        printf("Err init FSOUND :%s\n",FSOUND_Err(FSOUND_GetError()));
        exit(EXIT_FAILURE);
    }


    //creation de la fenetre.
    SDL_Surface* ecran = SDL_SetVideoMode(TAILLE_BLOCK*NB_BLOCK_LARG+240, TAILLE_BLOCK*NB_BLOCK_HAUT, 32,SDL_HWSURFACE|SDL_DOUBLEBUF);

    if (ecran==NULL)
    {//defaut de creation de la fenetre.
        printf("MAIN / Err init fenetre %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }


    // nom de la fenetre
    SDL_WM_SetCaption("Tetris_TE",NULL);


    //creation de la structure globale.
    S_global Sglobal;


    //initialisation de la structure globale.
    init_global(&Sglobal);

    //initialisation des infos.
    init_infos(Sglobal.Sinfos);


    //lecture du fichier de control.
    if (!lire_control(&Sglobal))
    {//gestion d'erreur.
        printf("Err initialisation des controles, application des parametres par defaut\n");
        init_control(Sglobal.Scontrol);
    }


    if (SDL_NumJoysticks())
    {//affectation des pads présents.

        //activation du pad.
        SDL_JoystickEventState(SDL_ENABLE);

        //attribution des pads branchés.
        pad_set(Sglobal.Scontrol);

        //réattribution de l'index du pad si celui du fichier
        //a un index superieur au nombre de pad branchés.
        if (SDL_NumJoysticks()<Sglobal.Scontrol->numPad)
            Sglobal.Scontrol->numPad=0;
    }
    else
    {//forçage clavier
        Sglobal.Scontrol->joy=NULL;
        Sglobal.Scontrol->modeControl=0;
    }


    //init du random.
    srand(time(NULL));


    /***** Boucle principale *****/

    while(! fin)
    {//boucle principale

        switch (menu_principal(ecran, &Sglobal))
        {//branches menu
            case 1://lancement du jeu
                if (! jeu(ecran,&Sglobal))
                {
                    fin=true;
                }
            break;

            case 2://lancement des options
                if (! menu_options(ecran,&Sglobal))
                {
                    fin=true;
                }
            break;

            case 3://lancement de la pages des scores

                if (! menu_scores(ecran,&Sglobal))
                {
                    fin=true;
                }
            break;

            default://sortie
                fin=true;
            break;
        }
    }

    /***** Sortie *****/

    //sauvegarde des controles
    ecrire_control(&Sglobal);

    //fermeture des pads
    if (Sglobal.Scontrol->joy!=NULL)
        pad_reset (Sglobal.Scontrol);

    //libérations mémoire
    libere_global_mem(&Sglobal);
    SDL_FreeSurface(ecran);
    FSOUND_Close();
    TTF_Quit();
    SDL_Quit();

    exit(EXIT_SUCCESS);
}

#include <iostream>
#include <SDL/SDL.h>
#include <SDL/fmod.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_rotozoom.h>
#include "constantes.h"
#include "inputs.h"
#include "fichier.h"


int menu_principal(SDL_Surface *ecran, S_global *Sglobal)
{//menu principal ***VALIDE***

    /***** Déclarations *****/

    //recupération des pointeurs vers les stuctures utiles à la fonction
    //pour faciliter la lecture du code:
    S_input *Sinput=Sglobal->Sinput;

    //init des entrées
    init_input(Sinput);


    bool fin=false;//bit de maintien de boucle
    int retour=1;//valeur de retour de la fonction

//SDL

    SDL_Surface *surf_Menu=NULL;
    SDL_Surface *surf_Select=NULL;

    SDL_Rect MenuPos,//position du menu.
            SelectPos;//position de la fleche de selection.

    //image menu
    if ((surf_Menu=SDL_LoadBMP("pics/menu.bmp"))==NULL)
    {//gestion de l'erreur
        printf("Err chargement de menu.bmp :%s\n",SDL_GetError());
        fin=true;
        retour=0;
    }
    else
    {//rect du menu.
        MenuPos.x=MenuPos.y=0;
        MenuPos.h=surf_Menu->h;
        MenuPos.w=surf_Menu->w;
    }


    //fleche de selection
    if ((surf_Select=SDL_LoadBMP("pics/select.bmp"))==NULL)
    {//gestion de l'erreur
        printf("Err chargement de select.bmp :%s\n",SDL_GetError());
        SDL_FreeSurface(surf_Menu);
        fin=true;
        retour=0;
    }
    else
    {//rect de la fleche de selection.
        SelectPos.x=160;
        SelectPos.y=285;
        SelectPos.h=surf_Select->h;
        SelectPos.w=surf_Select->w;
    }


    SDL_SetColorKey(surf_Select, SDL_SRCCOLORKEY, SDL_MapRGB(surf_Select->format, 125, 125, 125));

    //application du menu à l'ecran
    SDL_BlitSurface(surf_Menu,NULL,ecran,&MenuPos);

    //application de la fleche de selection
    SDL_BlitSurface(surf_Select,NULL,ecran,&SelectPos);

    //rafraichissement ecran
    SDL_Flip(ecran);

    /***** Boucle principale *****/

    while (! fin)
    {//boucle principale

        get_input(Sglobal);//actualisation des saisies

        if(Sinput->key[SDLK_F1])
        {//fullscreen
            switch_screen(ecran,Sglobal);

            //application du menu à l'ecran
            SDL_BlitSurface(surf_Menu,NULL,ecran,&MenuPos);

            //application de la fleche de selection
            SDL_BlitSurface(surf_Select,NULL,ecran,&SelectPos);

            //rafraichissement ecran
            SDL_Flip(ecran);

            Sinput->key[SDLK_F1]=false;
        }

        if (Sinput->key[SDLK_1])
        {//jeu
            retour=1;
            fin=true;
        }

        if(Sinput->key[SDLK_2])
        {//options
            retour=2;
            fin=true;
        }

        if(Sinput->key[SDLK_3])
        {//scores
            retour=3;
            fin=true;
        }

        if(Sinput->key[SDLK_4] || Sinput->quit)
        {//sortie
            retour=0;
            fin=true;
        }

        if (Sinput->key[SDLK_RETURN] || Sinput->padBt[ACT][0])
        {//envoie de la valeur du choix
            Sinput->key[SDLK_RETURN]=Sinput->padBt[ACT][0]=Sinput->padBt[PREV][0]=false;
            fin=true;
        }

        if ((Sinput->key[SDLK_DOWN] || Sinput->padHat[ACT][SDL_HAT_DOWN])
            && retour<4)
        {//si haut, monter la fleche
            SDL_FillRect(ecran,&SelectPos,SDL_MapRGB(ecran->format,0,0,0));//suppression de la fleche
            SelectPos.y+=50;
            SDL_BlitSurface(surf_Select,NULL,ecran,&SelectPos);//application de la fleche

            Sinput->key[SDLK_DOWN]=Sinput->padHat[ACT][SDL_HAT_DOWN]=false;
            retour++;

            SDL_Flip(ecran);
        }

        else if ((Sinput->key[SDLK_UP] || Sinput->padHat[ACT][SDL_HAT_UP])
            && retour>1)
        {//si bas, descendre la fleche
            SDL_FillRect(ecran,&SelectPos,SDL_MapRGB(ecran->format,0,0,0));//suppression de la fleche
            SelectPos.y-=50;
            SDL_BlitSurface(surf_Select,NULL,ecran,&SelectPos);//application de la fleche

            Sinput->key[SDLK_UP]=Sinput->padHat[ACT][SDL_HAT_UP]=false;
            retour--;

            SDL_Flip(ecran);
        }

        else
        {//par défaut reseter les entrées inutiles
            Sinput->key[SDLK_DOWN]=Sinput->key[SDLK_UP]=false;
            Sinput->padHat[ACT][SDL_HAT_UP]=Sinput->padHat[ACT][SDL_HAT_DOWN]=false;
        }


    }

    /***** Sortie *****/

    SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,0,0,0));//ecran noir

    SDL_Flip(ecran);

    //libération de la mémoire
    SDL_FreeSurface(surf_Menu);
    SDL_FreeSurface(surf_Select);

    return(retour);
}


int menu_scores (SDL_Surface *ecran,S_global *Sglobal)
{//liste les meilleurs scores ***VALIDE*** probleme fullscreen

    /***** Declarations *****/

    int i=0, j=0, //temporaires de boucles.
        retour=1;//valeur du retour.

    bool fin=false;//bit de maintien de boucle.

    char tampon[25];//texte filtré (notament la suppression du '\n').

    init_input(Sglobal->Sinput);//initialisation des entrées

    if (!lire_score(Sglobal->Sscore))//lecture du fichier des scores
            init_score(Sglobal->Sscore);


//SDL

    SDL_Surface *surf_text=NULL;//surface des textes.

    SDL_Color colorTxt={255,255,255,0};//couleur du text.

    //rect du text.
    SDL_Rect textPos;


//TTF

    //chargement de la police.
    TTF_Font *police=TTF_OpenFont("font/comic.ttf",30);

    if(police==NULL)
    {//gestion de l'erreur.
        printf("Err chargement de la police de characteres : %s\n",TTF_GetError());
        return (0);
    }
    else
    {
        TTF_SetFontStyle(police,TTF_STYLE_NORMAL);
    }


    /***** Preliminaires *****/

    textPos.x=150;
    textPos.y=5;

    if((surf_text=TTF_RenderText_Solid(police,"Meilleurs scores :",colorTxt))==NULL)
    {//gestion de l'erreur
        printf("Err création text du score : %s\n",SDL_GetError());
        fin=true;
        retour=0;
    }
    else
    {//MAJ du positionnement du text.
        SDL_BlitSurface(surf_text,NULL,ecran,&textPos);
        SDL_FreeSurface(surf_text);
    }

    textPos.x=180;
    textPos.y=30;

    for (i=0;i<10;i++)
    {//création des surfaces de text.

        j=0;
        sprintf(tampon,"%d:  ",i+1);

        while ((Sglobal->Sscore->score[i][j])!='\n' && j<20)
        {//nettoyage de la chaine.
            tampon[j+4]=Sglobal->Sscore->score[i][j];
            j++;
        }
        tampon[j+4]=Sglobal->Sscore->score[i][j]='\0';


        if((surf_text=TTF_RenderText_Solid(police,tampon,colorTxt))==NULL)
        {//gestion de l'erreur
            printf("Err création text du score : %s\n",SDL_GetError());
            fin=true;
            retour=0;
        }
        else
        {//MAJ du positionnement du text.
        textPos.w=surf_text->w;
        textPos.h=surf_text->h;
        textPos.y+=50;
        }

        //application du text.
        SDL_BlitSurface(surf_text,NULL,ecran,&textPos);


        //suppression de la surface.
        SDL_FreeSurface(surf_text);
    }

    SDL_Flip(ecran);


    /***** Boucle D'attente *****/

    while(! fin)
    {//attente d'une action utilisateur.
        get_input(Sglobal);

        if (Sglobal->Sinput->padBt[ACT][1] || Sglobal->Sinput->key[SDLK_ESCAPE])
            fin=true;

        if (Sglobal->Sinput->quit)
        {//sortie du prgm.
            retour=0;
            fin=true;
        }

    }

    /**** Sortie *****/

    TTF_CloseFont(police);
    return(retour);
}


int menu_options (SDL_Surface *ecran, S_global *Sglobal)
{//options ***VALIDE***

    /****** recupération des variables *******/

    S_input *Sinput=Sglobal->Sinput;

    S_temp Stemp;

    Stemp.padNum=Sglobal->Scontrol->numPad;//copie.
    Stemp.skinNum=Sglobal->Sinfos->skin;//copie.
    Stemp.tuneNum=Sglobal->Sinfos->tune;//copie.
    Stemp.control=Sglobal->Scontrol->modeControl;//copie
    Stemp.btDroit=Sglobal->Scontrol->padBtDroite;//copie
    Stemp.btGauc=Sglobal->Scontrol->padBtGauche;//copie
    Stemp.clavDroit=Sglobal->Scontrol->clavierDroite;//copie
    Stemp.clavGauc=Sglobal->Scontrol->clavierGauche;//copie


    /***** déclaration des variables ******/


    bool fin=false;//fin de boucle.

    int i=0,//temporaire.
        selection=0, //index de ligne.
        increment=0, //sens de selection.
        retour=1; //valeur du return.


    char padName[25],//nom du pad.
        skinFile[20],//nom du fichier du skin.
        musicFile[20],//nom du fichier de musique.
        tuneName[20],//nom de la musique.
        touches[10];//touches affectées.


//SDL

    SDL_Color colorTxt={255,255,255,0};//couleur du text (blanc).

    SDL_Surface *surf_padName=NULL,//surface nom du pad.
                *surf_musicName=NULL,//surface nom de la musique.
                *surf_option=NULL,//surface image de fond.
                *surf_select=NULL,//fleche de selection.
                *surf_skin=NULL,//skin.
                *surf_modCtrl[2]={NULL},//images du type de control.
                *surf_touches=NULL;//images des affectations.

    SDL_Rect optPos,//position d'affichage de l'image de fond.
            selectPos,//position d'affichage de la fleche de sélection.
            modPos,//position d'affichage du mode de controle.
            skinPos,//position d'affichage du skin.
            padTxtPos,//position d'affichage du nom du pad.
            musicTxtPos,//position d'affichage du nom de la musique.
            touchesPos;//position du text affectation.


//TTF

    TTF_Font *police=NULL;//police.

//FMOD

    FMUSIC_MODULE *tune=NULL;//musique.

    /***** Initialisation des variables *******/

    //initialisation des controles.
    init_input(Sinput);


    //init de padName.
    if (Stemp.control==1)
        sprintf(padName,SDL_JoystickName(Stemp.padNum));
    else
        sprintf(padName,"clavier");


    //init de skinFile.
    sprintf(skinFile,"pics/skin%d.bmp",Stemp.skinNum);


    if (Stemp.tuneNum)
    {
        //init de musicFile.
        sprintf(musicFile,"sounds/tune%d.mod",Stemp.tuneNum);


        //Chargement de la musique.
        if ((tune=FMUSIC_LoadSong(musicFile))==NULL)
        {//gestion de l'erreur
            printf("Err / chargement musique : %s\n",FSOUND_Err(FSOUND_GetError()));
            fin=true;
        }
        else
        {//lancement de la musique.
            FMUSIC_SetLooping(tune,true);
            FMUSIC_PlaySong(tune);
            sprintf(tuneName,FMUSIC_GetName(tune));
        }
    }
    else
    {
        tune=NULL;
        sprintf(tuneName,"Aucune");
    }





    //chargement de la police.
    police=TTF_OpenFont("font/comic.ttf",20);


    if(police==NULL)
    {//gestion de l'erreur.
        printf("Err chargement de la police de characteres : %s\n",TTF_GetError());
        fin=true;
        retour=0;
    }
    else
        TTF_SetFontStyle(police,TTF_STYLE_NORMAL);


    //surf_padName.
    if ((surf_padName=TTF_RenderText_Solid(police,padName,colorTxt))==NULL)
    {//gestion de l'erreur.
        printf("option / Err de création de surf_padName :%s\n",SDL_GetError());
        fin=true;
        retour=0;
    }
    else
    {//rect du nom du pad.
        padTxtPos.x=200;
        padTxtPos.y=202;
        padTxtPos.h=surf_padName->h;
        padTxtPos.w=surf_padName->w;
    }


    //surf_musicName.
    if ((surf_musicName=TTF_RenderText_Solid(police,tuneName,colorTxt))==NULL)
    {//gestion de l'erreur
        printf("option / Err de création de surf_musicName :%s\n",TTF_GetError());
        fin=true;
        retour=0;
    }
    else
    {//rect du nom du music.
        musicTxtPos.x=155;
        musicTxtPos.y=352;
        musicTxtPos.h=surf_musicName->h;
        musicTxtPos.w=surf_musicName->w;
    }


    //surf_option.
    if((surf_option=SDL_LoadBMP("pics/options.bmp"))==NULL)
    {//gestion de l'erreur.
        printf("Err de chargement de options.bmp :%s\n",SDL_GetError());
        fin=true;
        retour=0;
    }
    else
    {//rect du menu.
        optPos.x=optPos.y=0;
        optPos.h=surf_option->h;
        optPos.w=surf_option->w;
    }


    //surf_select.
    if ((surf_select=SDL_LoadBMP("pics/select.bmp"))==NULL)
    {//gestion de l'erreur
        printf("Err de chargement de select bmp :%s\n",SDL_GetError());
        fin=true;
        retour=0;
    }
    else
    {//rect de la fleche de selection
        selectPos.x=5;
        selectPos.y=205;
        selectPos.h=surf_select->h;
        selectPos.w=surf_select->w;
    }


    //suppression du gris de la fleche de selection.
    SDL_SetColorKey(surf_select,SDL_SRCCOLORKEY,SDL_MapRGB(surf_select->format, 125, 125, 125));


    //surf_modCtrl[1].
    if ((surf_modCtrl[1]=IMG_Load("pics/joystick.jpeg"))==NULL)
    {//gestion de l'erreur.
        printf("Err de chargement de joystick.jpeg :%s\n",SDL_GetError());
        fin=true;
        retour=0;
    }


    //surf_modCtrl[0].
    if ((surf_modCtrl[0]=IMG_Load("pics/clavier.jpeg"))==NULL)
    {//gestion de l'erreur.
        printf("Err de chargement de clavier.jpeg :%s\n",SDL_GetError());
        fin=true;
        retour=0;
    }
    else
    {//rect de l'image controle.
        modPos.x=150;
        modPos.y=205;
        modPos.h=modPos.w=30;
    }


    //surf_skin.
    if ((surf_skin=SDL_LoadBMP(skinFile))==NULL)
    {//gestion de l'erreur.
        printf("Err de chargement du skinset :%s\n",SDL_GetError());
        fin=true;
        retour=0;
    }
    else
    {//rect des skins.
        skinPos.x=150;
        skinPos.y=300;
        skinPos.h=surf_skin->h;
        skinPos.w=surf_skin->w;
    }


    /****** Boucle Principale *******/

    while (!fin)
    {//boucle principale

        get_input(Sglobal);//actualisation des saisies

        if (Sinput->quit)
        {//quitter le programme
            retour=0;
            fin=true;
        }

        if(Sinput->key[SDLK_F1])
        {//fullscreen
            switch_screen(ecran,Sglobal);
            Sglobal->Sinput->key[SDLK_F1]=false;
        }

        if (Sinput->key[SDLK_ESCAPE] || Sinput->padBt[ACT][1])
        {//echap
            Sinput->key[SDLK_ESCAPE]=Sinput->padBt[ACT][1]=Sinput->padBt[PREV][1]=false;
            fin=true;
        }

        if ((Sinput->key[SDLK_DOWN] || Sinput->padHat[ACT][SDL_HAT_DOWN]) && selection<5)
        {//si haut, monter la fleche

            selection++;

            if (selection<4)
                selectPos.y+=50;
            else if (selection==4)
            {
                selectPos.y+=100;
                selectPos.x=150;
            }
            else
            {
                selectPos.y+=50;
                selectPos.x=90;
            }

            SDL_BlitSurface(surf_select,NULL,ecran,&selectPos);//application de la fleche

            Sinput->key[SDLK_DOWN]=Sinput->padHat[ACT][SDL_HAT_DOWN]=false;

            SDL_Flip(ecran);
        }

        else if ((Sinput->key[SDLK_UP] || Sinput->padHat[ACT][SDL_HAT_UP]) && selection>0)
        {//si bas, descendre la fleche
            selection--;

            if (selection<3)
            {//positionnement fleche
                selectPos.y-=50;
            }
            else if (selection==4)
            {
                selectPos.y-=50;
                selectPos.x=150;
            }
            else
            {
                selectPos.y-=100;
                selectPos.x=5;
            }

            Sinput->key[SDLK_UP]=Sinput->padHat[ACT][SDL_HAT_UP]=false;
        }

        else
        {//par défaut reseter les entrées inutiles
            Sinput->key[SDLK_DOWN]=Sinput->key[SDLK_UP]=false;
            Sinput->padHat[ACT][SDL_HAT_UP]=Sinput->padHat[ACT][SDL_HAT_DOWN]=false;

            if (selection==0 || selection==2 || selection==3)
                Sinput->key[SDLK_RETURN]=false;
        }

        if (Sinput->key[SDLK_LEFT] || Sinput->padHat[ACT][SDL_HAT_LEFT])
        {//a gauche
            increment=-1;
            Sinput->key[SDLK_LEFT]=Sinput->padHat[ACT][SDL_HAT_LEFT]=0;
        }

        if (Sinput->key[SDLK_RIGHT] || Sinput->padHat[ACT][SDL_HAT_RIGHT])
        {//à droite
            increment=1;
            Sinput->key[SDLK_RIGHT]=Sinput->padHat[ACT][SDL_HAT_RIGHT]=0;
        }

        switch(Stemp.control)
        {//affichage des touches de control
            case 0:
            {
                sprintf(touches,"%c et %c",Stemp.clavDroit,Stemp.clavGauc);
            }
            break;

            case 1:
            {
                sprintf(touches,"%d et %d",Stemp.btDroit,Stemp.btGauc);
            }
            break;

            default:
            {
                Stemp.control=0;
            }
            break;
        }

        if ((surf_touches=TTF_RenderText_Solid(police,touches,colorTxt))==NULL)
        {//gestion de l'erreur
            printf("option / Err de création de surf_touches :%s\n",TTF_GetError());
            fin=true;
            retour=0;
        }
        else
        {
            touchesPos.x=160;
            touchesPos.y=250;
            touchesPos.w=surf_touches->w;
            touchesPos.h=surf_touches->h;
        }



        switch(selection)
        {//action selon ligne
            case 0:
            {// ligne 0 mode de control.
                if (increment)
                {
                    switch (Stemp.control)
                    {
                        case 0 :
                        {//clavier->pad

                            if(SDL_NumJoysticks())
                            {
                                Stemp.control=1;

                                if (increment>0)
                                    Stemp.padNum=0;
                                else
                                    Stemp.padNum=SDL_NumJoysticks()-1;

                                SDL_FreeSurface(surf_padName);

                                sprintf(padName,SDL_JoystickName(Stemp.padNum));

                                if ((surf_padName=TTF_RenderText_Solid(police,padName,colorTxt))==NULL)
                                {//gestion de l'erreur
                                    printf("option / Err de création de surf_padName :%s\n",TTF_GetError());
                                    fin=true;
                                    retour=0;
                                }
                            }
                        }
                        break;

                        case 1 :
                        {//scan des pad -> clavier
                            if ((Stemp.padNum+increment>=0) && ((Stemp.padNum+increment)<SDL_NumJoysticks()))
                            {
                                Stemp.padNum=Stemp.padNum+increment;
                                sprintf(padName,SDL_JoystickName(Stemp.padNum));
                            }
                            else
                            {
                                Stemp.control=Stemp.padNum=0;
                                sprintf(padName,"clavier");
                            }

                            SDL_FreeSurface(surf_padName);

                            if ((surf_padName=TTF_RenderText_Solid(police,padName,colorTxt))==NULL)
                            {//gestion de l'erreur
                                printf("option / Err de création de surf_padName :%s\n",TTF_GetError());
                                fin=true;
                                retour=0;
                            }
                        }
                        break;
                    }
                }
            }
            break;

            case 1:
            {//ligne 1 choix des controles.

                switch (Stemp.control)
                {
                    case 0:
                    {
                        if(Sinput->key[SDLK_RETURN])
                        {
                            if (!saisie_cfg(ecran,&Stemp))
                            {
                                retour=0;
                                fin=true;
                            }

                            Sinput->key[SDLK_RETURN]=false;
                        }
                    }
                    break;

                    case 1:
                    {
                        if(Sinput->padBt[ACT][0])
                        {
                            if (!saisie_cfg(ecran,&Stemp))
                            {
                                retour=0;
                                fin=true;
                            }

                        Sinput->padBt[ACT][0]=Sinput->padBt[PREV][0]=false;
                        }
                    }
                    break;

                    default:
                    break;
                }
            }
            break;

            case 2:
            {//ligne 2 skin.

                if (increment)
                {
                    SDL_FreeSurface(surf_skin);

                    if(Stemp.skinNum+increment<0)
                        Stemp.skinNum=NB_SKIN-1;
                    else if (Stemp.skinNum+increment>NB_SKIN-1)
                        Stemp.skinNum=0;
                    else
                        Stemp.skinNum+=increment;

                    sprintf(musicFile,"pics/skin%d.bmp",Stemp.skinNum);

                    if ((surf_skin=SDL_LoadBMP(musicFile))==NULL)
                    {//gestion de l'erreur
                        printf("Err de chargement du skinset :%s\n",SDL_GetError());
                        fin=true;
                        retour=0;
                    }
                }
            }
            break;

            case 3:
            {//ligne 3 musiques.

                if (increment)
                {//selection droite / gauche
                    FMUSIC_StopSong(tune);
                    FMUSIC_FreeSong(tune);


                    if(Stemp.tuneNum+increment<0)
                        Stemp.tuneNum=NB_TUNE-1;
                    else if (Stemp.tuneNum+increment>NB_TUNE)
                        Stemp.tuneNum=0;
                    else
                        Stemp.tuneNum+=increment;

                    if (Stemp.tuneNum)
                    {
                        sprintf(musicFile,"sounds/tune%d.mod",Stemp.tuneNum);

                        if ((tune=FMUSIC_LoadSong(musicFile))==NULL)
                        {//gestion de l'erreur.
                            printf("Err de chargement du tune :%s\n",FSOUND_Err(FSOUND_GetError()));
                            fin=true;
                            retour=0;
                        }
                        else
                        {//MAJ affichage et lancement musique.
                            FMUSIC_SetLooping(tune,false);
                            FMUSIC_PlaySong(tune);
                            sprintf(tuneName,FMUSIC_GetName(tune));
                        }
                    }
                    else
                    {

                        tune=NULL;
                        sprintf(tuneName,"Aucune");
                    }

                    SDL_FreeSurface(surf_musicName);

                    if ((surf_musicName=TTF_RenderText_Solid(police,tuneName,colorTxt))==NULL)
                    {//gestion de l'erreur
                        printf("option / Err de création de surf_musicName :%s\n",TTF_GetError());
                        fin=true;
                        retour=0;
                    }
                }
            }
            break;

            case 4:
            {//quitter
                if (Sinput->key[SDLK_RETURN] || Sinput->padBt[ACT][0])
                    fin=true;
            }
            break;

            case 5:
            {//quitter et sauvegarder
                if (Sinput->key[SDLK_RETURN] || Sinput->padBt[ACT][0])
                {
                    Sglobal->Scontrol->numPad=Stemp.padNum;//copie.
                    Sglobal->Sinfos->skin=Stemp.skinNum;//copie.
                    Sglobal->Sinfos->tune=Stemp.tuneNum;//copie.
                    Sglobal->Scontrol->modeControl=Stemp.control;//copie
                    Sglobal->Scontrol->padBtDroite=Stemp.btDroit;//copie
                    Sglobal->Scontrol->padBtGauche=Stemp.btGauc;//copie
                    Sglobal->Scontrol->clavierDroite=Stemp.clavDroit;//copie
                    Sglobal->Scontrol->clavierGauche=Stemp.clavGauc;//copie

                    fin=true;
                }
            }
            break;

            default:
            break;
        }

        increment=0;

        //application du menu à l'ecran.
        SDL_BlitSurface(surf_option,NULL,ecran,&optPos);

        //application de la fleche de selection.
        SDL_BlitSurface(surf_select,NULL,ecran,&selectPos);

        //application du mode de control.
        SDL_BlitSurface(surf_modCtrl[Stemp.control],NULL,ecran,&modPos);

        //application du nom du pad.
        SDL_BlitSurface(surf_padName,NULL,ecran,&padTxtPos);

        //application du skin.
        SDL_BlitSurface(surf_skin,NULL,ecran,&skinPos);

        //application du nom de la musique.
        SDL_BlitSurface(surf_musicName,NULL,ecran,&musicTxtPos);

        //application des touches.
        SDL_BlitSurface(surf_touches,NULL,ecran,&touchesPos);

        //rafraichissement ecran.
        SDL_Flip(ecran);

        SDL_Delay(50);

    }//fin de boucle principale.


    /******Sortie******/

    SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,0,0,0));//ecran noir

    SDL_Flip(ecran);

    FMUSIC_StopSong(tune);


    //libération de la mémoire.
    for (i=0;i<2;i++)
    SDL_FreeSurface(surf_modCtrl[i]);

    SDL_FreeSurface(surf_musicName);
    SDL_FreeSurface(surf_padName);
    SDL_FreeSurface(surf_option);
    SDL_FreeSurface(surf_select);
    SDL_FreeSurface(surf_skin);

    TTF_CloseFont(police);

    FMUSIC_FreeSong(tune);

    return(retour);
}


int menu_best(SDL_Surface *ecran, S_global *Sglobal, int score)
{//enregistrement des records ***EN COURS***

    /*****Declarations*****/

    //Reprise :
    S_score *Sscore=Sglobal->Sscore;

    int rank=compare_score(score,Sscore),//classement.
        retour=1,//valeur de retour de la fonction.
        charPos=0,
        tickPrec=SDL_GetTicks(),
        tickAct=tickPrec;

    float i=0.0,//temporaire.
        angle=0.0;//angle d'affichage.

    bool fin=false,//bolléen de fin de boucle.
        alt=false;//bool d'alternance du char.


    char actChar='a',//char actuel.
        txtrank[20],//text du classement.
        nom[4]="aaa";//nom avant modif.

        sprintf(txtrank,"nouveau classement : %d",compare_score(score,Sglobal->Sscore)+1);

    SDL_Rect rankPos;
    rankPos.x=20;
    rankPos.y=5;

    SDL_Rect nomPos;
    nomPos.x=250;
    nomPos.y=100;

    SDL_Rect cupPos;

    SDL_Color colorTxt={255,255,255,0};

    SDL_Event event;

    SDL_EnableKeyRepeat(1000,200);

    SDL_Surface *surf_cup=NULL;
    SDL_Surface *surf_cupTemp=NULL;
    SDL_Surface *surf_nom=NULL;
    SDL_Surface *surf_rank=NULL;

    FSOUND_SAMPLE *applause=NULL;

    TTF_Font *police=NULL;

    if((police=TTF_OpenFont("font/comic.ttf",40))==NULL)
    {//gestion de l'erreur.
        printf("Err / chargement de comic.ttf %s\n",TTF_GetError());
        retour=0;
        fin=true;
    }


    if ((surf_cup=SDL_LoadBMP("pics/cup.bmp"))==NULL)
    {//gestion de l'erreur.
        retour=0;
        fin=true;
        printf("Err / chargement de cup.bmp :%s",SDL_GetError());
    }


    if ((applause=FSOUND_Sample_Load(FSOUND_FREE,"sounds/applause.wav",0,0,0))==NULL)
    {//gestion de l'erreur.
        printf("Err / chargement de applause.wav :%s\n",FSOUND_Err(FSOUND_GetError()));
        retour=0;
        fin=true;
    }
    else
    {
        FSOUND_PlaySound(FSOUND_FREE,applause);
    }

    /*****Intro*****/

    for (i=0.01,angle=0;i<=0.73;i+=0.01)
    {//boucle d'animation de la coupe.

        //nettoyage de l'écran.
        SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,0,0,0));

        //nouvelle image
        surf_cupTemp=rotozoomSurface(surf_cup,angle,i,SMOOTHING_OFF);

        angle=1000*i;

        cupPos.x=(ecran->w/2-cupPos.w/2);
        cupPos.y=(ecran->h/2-cupPos.h/2);

        SDL_BlitSurface(surf_cupTemp,NULL,ecran,&cupPos);

        SDL_Flip(ecran);

        SDL_Delay(20);
    }

    surf_cupTemp=rotozoomSurface(surf_cup,0,0.75,SMOOTHING_OFF);
    SDL_BlitSurface(surf_cupTemp,NULL,ecran,&cupPos);
    SDL_Flip(ecran);

    SDL_Delay(2000);


    /****Boucle principale*****/


    while(!fin)
    {//boucle de saisie.
        while (SDL_PollEvent(&event))
        {

            switch (event.type)
            {
                case SDL_QUIT:
                    fin=true;
                    retour=0;
                break;

                case SDL_KEYDOWN :

                    switch (event.key.keysym.sym)
                    {
                        case SDLK_UP :

                            if (actChar+1<=122)
                                actChar++;

                            nom[charPos]=actChar;

                        break;

                        case SDLK_DOWN :

                            if (actChar-1>=97)
                                actChar--;

                            nom[charPos]=actChar;

                        break;

                        case SDLK_LEFT :

                            nom[charPos]=actChar;

                            if (charPos-1>=0)
                            {
                                charPos--;
                                actChar=nom[charPos];
                            }
                        break;

                        case SDLK_RIGHT :

                            nom[charPos]=actChar;

                            if (charPos+1<=2)
                            {
                                charPos++;
                                actChar=nom[charPos];
                            }
                        break;

                        case SDLK_RETURN :

                            nom[charPos]=actChar;
                            fin=true;
                        break;

                        default:
                        break;
                    }
                break;

                default :
                break;
            }
        }

        if ((surf_nom=TTF_RenderText_Solid(police,nom,colorTxt))==NULL)
            {
                printf("Erreur de création de surf_nom :%s\n",TTF_GetError());
                retour=0;
                fin=true;
            }

        if ((surf_rank=TTF_RenderText_Solid(police,txtrank,colorTxt))==NULL)
            {
                printf("Erreur de création de surf_rank :%s\n",TTF_GetError());
                retour=0;
                fin=true;
            }

        tickAct=SDL_GetTicks();


        if (tickAct<tickPrec+500 && !alt)
        {
            actChar=nom[charPos];
            nom[charPos]='_';
            alt=true;
        }
        else if (tickAct>=tickPrec+500)
        {
            nom[charPos]=actChar;
            alt=false;
        }

        if (tickAct>=tickPrec+1000)
            tickPrec=SDL_GetTicks();

        SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,0,0,0));

        SDL_BlitSurface(surf_cupTemp,NULL,ecran,&cupPos);

        SDL_BlitSurface(surf_rank,NULL,ecran,&rankPos);

        SDL_BlitSurface(surf_nom,NULL,ecran,&nomPos);

        SDL_Flip(ecran);

        SDL_Delay(20);
    }

    /****Sortie*****/

    save_record(Sscore,nom,rank,score);

    SDL_FreeSurface(surf_cup);
    SDL_FreeSurface(surf_cupTemp);
    SDL_FreeSurface(surf_rank);
    SDL_FreeSurface(surf_nom);

    FSOUND_Sample_Free(applause);

    TTF_CloseFont(police);

    return(retour);
}

#include <iostream>
#include <SDL/SDL.h>
#include <SDL/fmod.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_image.h>
#include "constantes.h"
#include "inputs.h"
#include "jeu_fnctns.h"
#include "fichier.h"
#include "menu.h"



int jeu(SDL_Surface *ecran, S_global *Sglobal)
{//Le jeu en lui-même ***VALIDE***

    /***** Declarations *****/

    //reprise des structures.
    S_control *Scontrol=Sglobal->Scontrol;
    S_score *Sscore=Sglobal->Sscore;
    S_input *Sinput=Sglobal->Sinput;


    //piece actuelle et next :
    S_piece pieceAct,pieceNxt;


    char nomFichier[15];//nom du fichier à charger

    bool fin=false;//bit de validité de boucle.

    int i=0,j=0,//variables temporaires de boucles.
        retour=1,//valeur de retour de fonction.
        ligneADecaler=0,//nombre de ligne à supprimer.
        nbLigne=0,//nombre de ligne supprimées.
        score=0,//score.
        tempLigne=0,//temporaire de calcul de front.
        level=0,//niveau en cours.
        tempsPrec=0,//memo temps pour comparaison.
        tempsAct=0,//temps actuel.
        mouvement=RIEN,//mouvement en cours.
        difficulteVit=1000;//difficulté (vitesse).


    bool tableau[NB_BLOCK_LARG][NB_BLOCK_HAUT]={false},//tableau de jeu.
        newPiece=false,//lancement d'une piece.
        frontLvl=false;//front montant.

    //vidange de la matrice.
    for(i=0;i<NB_BLOCK_HAUT;i++)
        for(j=0;j<NB_BLOCK_LARG;j++)
            tableau[j][i]=false;

    //initialisation.
    init_input(Sinput);

    //lecture du fichier de scores.
    if (!lire_score(Sscore))
        init_score(Sscore);


//SDL

    SDL_Rect tempPos;

    //chargement du tableau de bord.
    SDL_Surface *board=IMG_Load("pics/board.jpg");

    if (board==NULL)
    {//gestion de l'erreur.
        printf("JEU / Err chargement de board.jpg");
        fin=true;
        retour=0;
    }
    else
    {//SDL_Rect.
    tempPos.x=BOARDPOS;
    tempPos.y=0;
    tempPos.h=board->h;
    tempPos.w=board->w;
    }

    //application du tableau de bord.
    SDL_BlitSurface(board,NULL,ecran,&tempPos);

//Création de la surface du skin.
    sprintf(nomFichier,"pics/skin%d.bmp",Sglobal->Sinfos->skin);
    SDL_Surface* carre=SDL_LoadBMP(nomFichier);

    if (carre==NULL)
    {//gestion de l'erreur.
        printf("Err / chargement skin :%s\n",SDL_GetError());
        fin=true;
        retour=0;
    }

//Chargement de la musique

    FMUSIC_MODULE *tune=NULL;

    if (Sglobal->Sinfos->tune)
    {//si musique.
        sprintf(nomFichier,"sounds/tune%d.mod",Sglobal->Sinfos->tune);
        tune=FMUSIC_LoadSong(nomFichier);

        if (tune==NULL)
        {//gestion de l'erreur.
            printf("Err / chargement musique :%s\n",FSOUND_Err(FSOUND_GetError()));
            fin=true;
            retour=0;
        }
        else
        {//démarrage musique
            FMUSIC_SetLooping(tune,true);
            FMUSIC_PlaySong(tune);
        }
    }


//GESTION DU NOMBRE DE LIGNE :

    char charNbLigne[5];

    //POLICE ET COULEUR DU TEXTE
    TTF_Font *police=TTF_OpenFont("font/comic.ttf",30);

    if(police==NULL)
    {//gestion de l'erreur
        printf("Err chargement de la police de characteres\n");
        fin=true;
        retour=0;
    }
    else
    {//format de police
        TTF_SetFontStyle(police,TTF_STYLE_NORMAL);
    }

    /***** Preliminaire*****/


    sprintf(charNbLigne,"%d",nbLigne);

    //positionnement de l'affichage du nombre de ligne :
    SDL_Rect dispLinePos;
    dispLinePos.x=370;
    dispLinePos.y=352;
    dispLinePos.h=dispLinePos.w=0;

    disp_texte(ecran,charNbLigne,police,&dispLinePos);

//GESTION AFFICHAGE DU SCORE :

    char charScore[10];

    sprintf(charScore,"%d",score);

    //positionnement de l'affichage :
    SDL_Rect dispScorePos;
    dispScorePos.x=370;
    dispScorePos.y=472;
    dispScorePos.h=dispScorePos.w=0;

    disp_texte(ecran,charScore,police,&dispScorePos);

//GESTION AFFICHAGE LEVEL :

    char charLvl[5];

    sprintf(charLvl,"%d",level);

    //positionnement de l'affichage :
    SDL_Rect dispLvlPos;
    dispLvlPos.x=370;
    dispLvlPos.y=230;
    dispLvlPos.h=dispLvlPos.w=0;

    disp_texte(ecran,charLvl,police,&dispLvlPos);

   // bool fin=false;//bit de validité de boucle

    //initialisation des premiere pieces :
    init_piece(&pieceAct,carre,rand()%7);
    init_piece(&pieceNxt,carre,rand()%7);
    disp_next(ecran,&pieceNxt);

    SDL_EnableKeyRepeat(100,100);

    /***** Boucle Principale*****/

    while (!fin)
    {//boucle principale du jeu


        get_input(Sglobal);//lectures des entrées utilisateur
        tempsAct=SDL_GetTicks();

        if (newPiece)
        {//gestion d'envoi d'une nouvelle piece
            init_piece(&pieceAct,carre,pieceNxt.type);
            init_piece(&pieceNxt,carre,rand()%7);
            disp_next(ecran,&pieceNxt);
            newPiece=false;
        }

        if (frontLvl)
        {//action toutes les 10 lignes :
            difficulteVit-=50;
            score+=1000;
            level++;

            sprintf(charLvl,"%d",level);

            disp_texte(ecran,charLvl,police,&dispLvlPos);

            frontLvl=false;
        }

        if (Sinput->quit)
        {//croix quitter
            Sinput->quit=false;
            retour=0;
            score=0;
            fin=true;
        }

        if(Sinput->key[SDLK_F1])
        {//fullscreen
            switch_screen(ecran,Sglobal);

            //ré-application des surfaces.
            SDL_BlitSurface(board,NULL,ecran,&tempPos);
            disp_texte(ecran,charNbLigne,police,&dispLinePos);
            disp_texte(ecran,charScore,police,&dispScorePos);
            disp_texte(ecran,charLvl,police,&dispLvlPos);
            disp_next(ecran,&pieceNxt);
            SDL_Flip(ecran);

            Sinput->key[SDLK_F1]=false;
        }

        if(Sinput->key[SDLK_ESCAPE])
        {//touche echap
            Sinput->key[SDLK_ESCAPE]=false;
            score=0;
            fin=true;
        }

        if(!Scontrol->modeControl && Sinput->key[Scontrol->clavierGauche]
            || Scontrol->modeControl && Sinput->padBt[ACT][0])
        {//si rotation gauche
            mouvement=ROT_G;
            Sinput->key[Scontrol->clavierGauche]=false;
            Sinput->padBt[ACT][0]=false;
        }

        if(!Scontrol->modeControl && Sinput->key[Scontrol->clavierDroite]
            || Scontrol->modeControl && Sinput->padBt[ACT][1])
        {//si rotation droite
            mouvement=ROT_D;
            Sinput->key[Scontrol->clavierDroite]=false;
            Sinput->padBt[ACT][1]=false;
        }

        if (!Scontrol->modeControl && Sinput->key[SDLK_RIGHT]
            || Scontrol->modeControl && Sinput->padHat[ACT][SDL_HAT_RIGHT])
        {//si commande droite
            mouvement=DROITE;
            Sinput->key[SDLK_RIGHT]=false;
            Sinput->padHat[ACT][SDL_HAT_RIGHT]=false;
        }

        if (!Scontrol->modeControl && Sinput->key[SDLK_LEFT]
            || Scontrol->modeControl && Sinput->padHat[ACT][SDL_HAT_LEFT])
        {//si commande gauche
            mouvement=GAUCHE;
            Sinput->key[SDLK_LEFT]=false;
            Sinput->padHat[ACT][SDL_HAT_LEFT]=false;
        }

        if (tempsAct-tempsPrec>=difficulteVit && mouvement!=BAS)
        {
            tempsPrec=SDL_GetTicks();
            mouvement=BAS;
        }

        if (mouvement!=BAS
            &&
                (!Scontrol->modeControl && Sinput->key[SDLK_DOWN]
                || Scontrol->modeControl && Sinput->padHat[ACT][SDL_HAT_DOWN])
            )
        {//si commande bas
            mouvement=BAS;
            score+=5;
            Sinput->key[SDLK_DOWN]=false;
            Sinput->padHat[Scontrol->numPad][SDL_HAT_DOWN]=false;
        }

        if (mouvement!=RIEN)
        {//s'il y a eu un mouvement :
            switch (test_Mvt(&pieceAct,tableau,mouvement))
            {//selon resultat du test de mouvement
                case 1://bouge la piece
                    bouger(ecran,&pieceAct,mouvement);
                break;

                case 2://fixe la piece dans la matrice
                    if (!(fixer(&pieceAct,tableau)))
                    {//game over si fixer() retourne 0
                        game_over(ecran,police);
                        fin=true;
                    }
                    else
                    {//sinon
                        do
                        {//control des lignes et décalage
                            ligneADecaler=test_ligne(tableau);//cherche une ligne complete

                            if (ligneADecaler)
                            {//décalage des ligne
                                decalage(ecran,tableau,ligneADecaler);
                                SDL_Delay(100);
                                SDL_Flip(ecran);
                                tempLigne++;

                                if (!((nbLigne+tempLigne)%10))//activation du front montant toutes les 10 lignes
                                    frontLvl=true;
                            }
                        }
                        while (ligneADecaler);//tant qu'il y a des lignes completes
                        nbLigne+=tempLigne;//comptage du nombre de ligne

                        for(i=1;i<=tempLigne;i++)
                        {//augmentation du score en fonction du nombre de lignes faite en un coup
                            score+=100*i;
                        }
                        tempLigne=0;

                        sprintf(charNbLigne,"%d",nbLigne);

                        disp_texte(ecran,charNbLigne,police,&dispLinePos);

                        newPiece=true;//lancement d'une nouvelle piece
                    }
                break;

                default :
                break;
            }
        }

        if (mouvement)
        {//actualisation des affichages
            sprintf(charScore,"%d",score);

            disp_texte(ecran,charScore,police,&dispScorePos);

            SDL_Flip(ecran);
            mouvement=RIEN;
        }
    }

    /***** Sortie *****/

        FMUSIC_StopSong(tune);

    //libération de la mémoire

        FMUSIC_FreeSong(tune);

        SDL_FreeSurface(carre);

        SDL_FreeSurface(board);
        TTF_CloseFont(police);

        if (score && compare_score(score,Sscore)>=-1)
        {//enregistrement du score
            if (!menu_best(ecran,Sglobal,score))
                retour=0;
        }

        if(!ecrire_score(Sscore))
        {//sauvegarde des scores dans le fichier
            printf("Err sauvegarde des scores\n");
        }

    return(retour);
}

#include <iostream>
#include <SDL/SDL.h>
#include "constantes.h"
#include <SDL/SDL_ttf.h>



void init_piece(S_piece *Spiece,SDL_Surface *bloc,const int forme)
{//initialisation de la structure piece ***VALIDE***

    Spiece->type=forme;
    Spiece->carre=bloc;
    Spiece->orientation=0;
    Spiece->decoup.x=TAILLE_BLOCK*forme;
    Spiece->decoup.y=0;
    Spiece->decoup.h=Spiece->decoup.w=TAILLE_BLOCK;

    for(int i=0;i<4;i++)
        Spiece->pos[i].h=Spiece->pos[i].w=TAILLE_BLOCK;

    switch (forme)
    {
        case BARRE:

            Spiece->pos[0].x=5;
            Spiece->pos[0].y=-1;
            Spiece->pos[1].x=4;
            Spiece->pos[1].y=-1;
            Spiece->pos[2].x=6;
            Spiece->pos[2].y=-1;
            Spiece->pos[3].x=7;
            Spiece->pos[3].y=-1;

        break;

        case TE:

            Spiece->pos[0].x=5;
            Spiece->pos[0].y=0;
            Spiece->pos[1].x=5;
            Spiece->pos[1].y=-1;
            Spiece->pos[2].x=4;
            Spiece->pos[2].y=0;
            Spiece->pos[3].x=6;
            Spiece->pos[3].y=0;

        break;

        case CARRE:

            Spiece->pos[0].x=4;
            Spiece->pos[0].y=-1;
            Spiece->pos[1].x=4;
            Spiece->pos[1].y=0;
            Spiece->pos[2].x=5;
            Spiece->pos[2].y=-1;
            Spiece->pos[3].x=5;
            Spiece->pos[3].y=0;

        break;

        case ESS:

            Spiece->pos[0].x=5;
            Spiece->pos[0].y=0;
            Spiece->pos[1].x=4;
            Spiece->pos[1].y=0;
            Spiece->pos[2].x=5;
            Spiece->pos[2].y=-1;
            Spiece->pos[3].x=6;
            Spiece->pos[3].y=-1;
        break;

        case ZED:

            Spiece->pos[0].x=5;
            Spiece->pos[0].y=0;
            Spiece->pos[1].x=6;
            Spiece->pos[1].y=0;
            Spiece->pos[2].x=5;
            Spiece->pos[2].y=-1;
            Spiece->pos[3].x=4;
            Spiece->pos[3].y=-1;

        break;

        case EL:

            Spiece->pos[0].x=5;
            Spiece->pos[0].y=-1;
            Spiece->pos[1].x=6;
            Spiece->pos[1].y=-1;
            Spiece->pos[2].x=4;
            Spiece->pos[2].y=-1;
            Spiece->pos[3].x=4;
            Spiece->pos[3].y=0;

        break;

        case LE:

            Spiece->pos[0].x=5;
            Spiece->pos[0].y=-1;
            Spiece->pos[1].x=4;
            Spiece->pos[1].y=-1;
            Spiece->pos[2].x=6;
            Spiece->pos[2].y=-1;
            Spiece->pos[3].x=6;
            Spiece->pos[3].y=0;

        break;
    }
}


int test_Mvt(S_piece *Spiece, const bool tableau[NB_BLOCK_LARG][NB_BLOCK_HAUT],const int direction)
{//la Spiece peut ou non bouger ***VALIDE***

    /***** Déclarations *****/

    int retour=1,//valeur de retour de la fonction.
        i=0,//temporaire de boucle.
        Xt=0,Yt=0,//encombrement X Y.
        TempX=0,TempY=0;//temporaire X Y.


    /***** Execution *****/

    for (i=0;i<4;i++)
    {
        switch (direction)
        {
            case BAS :
            {
                if (((Spiece->pos[i].y+1)>=NB_BLOCK_HAUT) || (tableau[Spiece->pos[i].x][Spiece->pos[i].y+1]))
                retour=2;
            }
            break;

            case DROITE :
            {
                if (Spiece->pos[i].x+1>=NB_BLOCK_LARG || tableau[Spiece->pos[i].x+1][Spiece->pos[i].y])
                retour=0;
            }
            break;

            case GAUCHE :
            {
                if (Spiece->pos[i].x-1<0 || tableau[Spiece->pos[i].x-1][Spiece->pos[i].y])
                    retour=0;
            }
            break;

            case ROT_D :
            {
                Xt=Spiece->pos[i].x-Spiece->pos[0].x;
                Yt=Spiece->pos[i].y-Spiece->pos[0].y;

                TempY=Spiece->pos[0].y+Xt;
                TempX=Spiece->pos[0].x-Yt;

                if (TempX>=NB_BLOCK_LARG || TempX<0 || TempY>=NB_BLOCK_HAUT || tableau[TempX][TempY])
                    retour=0;
            }
            break;

            case ROT_G :
            {
                Xt=Spiece->pos[i].x-Spiece->pos[0].x;
                Yt=Spiece->pos[i].y-Spiece->pos[0].y;

                TempY=Spiece->pos[0].y-Xt;
                TempX=Spiece->pos[0].x+Yt;

                if (TempX>=NB_BLOCK_LARG || TempX<0 || TempY>=NB_BLOCK_HAUT || tableau[TempX][TempY])
                    retour=0;
            }
        }
    }

    return(retour);
}


void bouger(SDL_Surface *ecran, S_piece *Spiece, int direction)
{//bouge une Spiece ***VALIDE***

    /***** Déclarations *****/

    int i=0,//temporaire de boucle
        Xt=0,Yt=0;

    SDL_Rect tempPos;

    tempPos.w=TAILLE_BLOCK;
    tempPos.h=TAILLE_BLOCK;


    /***** preliminaire *****/

    for(i=0;i<4;i++)
    {//efface la Spiece
        tempPos.x=BOARDPOS + TAILLE_BLOCK*Spiece->pos[i].x;
        tempPos.y=TAILLE_BLOCK*Spiece->pos[i].y;

        SDL_FillRect(ecran,&tempPos,SDL_MapRGB(ecran->format,0,0,0));
    }

    /***** execution *****/

    switch (direction)
    {
        case BAS :
        {
            for (i=0;i<4;i++)
                Spiece->pos[i].y++;
        }
        break;

        case DROITE :
        {
            for (i=0;i<4;i++)
                Spiece->pos[i].x++;
        }
        break;

        case GAUCHE :
        {
            for (i=0;i<4;i++)
                Spiece->pos[i].x--;
        }
        break;

        case ROT_D :
        {
            for (i=0;i<4;i++)
            {
                Xt=Spiece->pos[i].x-Spiece->pos[0].x;
                Yt=Spiece->pos[i].y-Spiece->pos[0].y;

                Spiece->pos[i].y=Spiece->pos[0].y+Xt;
                Spiece->pos[i].x=Spiece->pos[0].x-Yt;
            }

        }
        break;

        case ROT_G :
        {
            for (i=0;i<4;i++)
            {
                Xt=Spiece->pos[i].x-Spiece->pos[0].x;
                Yt=Spiece->pos[i].y-Spiece->pos[0].y;

                Spiece->pos[i].y=Spiece->pos[0].y-Xt;
                Spiece->pos[i].x=Spiece->pos[0].x+Yt;
            }
        }
        break;
    }

    for (i=0;i<4;i++)
    {//redessine la Spiece
        tempPos.x=BOARDPOS + TAILLE_BLOCK*Spiece->pos[i].x;
        tempPos.y=TAILLE_BLOCK*Spiece->pos[i].y;

        SDL_BlitSurface(Spiece->carre,&Spiece->decoup,ecran,&tempPos);
    }
}


int fixer(S_piece *Spiece, bool tableau[NB_BLOCK_LARG][NB_BLOCK_HAUT])
{//insert la Spiece dans la matrice ***VALIDE***

    int i=0,//temporaire de boucle.
        maxi=0;//valeur en coord Y du plus haut point de la Spiece

    for(i=0;i<4;i++)
    {//boucle de figeage
        tableau[Spiece->pos[i].x][Spiece->pos[i].y]=true;

        if (Spiece->pos[i].y>maxi)
            maxi=Spiece->pos[i].y;
    }

    return (maxi);

}


int test_ligne (bool tableau[NB_BLOCK_LARG][NB_BLOCK_HAUT])
{//renvoie le numero de ligne à supprimer sinon ZERO ***VALIDE***

    int i=NB_BLOCK_HAUT-1,j=0,//temporaires de boucle.
        colonneNB=0;//nombre de colonnes pleines.

    for (i=NB_BLOCK_HAUT-1;i>=0;i--)
    {
        for(j=0;j<NB_BLOCK_LARG;j++)
        {
            if (tableau[j][i])
                colonneNB++;
        }

        if (colonneNB==NB_BLOCK_LARG)
            return (i);

        colonneNB=0;
    }

    return (0);
}


void decalage (SDL_Surface *ecran, bool tableau[NB_BLOCK_LARG][NB_BLOCK_HAUT],int ligne)
{//effectue le décalage graphique et matrice ***VALIDE***

    int i=0,j=0;//temporaires de boucle.

    SDL_Rect tempPos,//temporaire.
            decoupe;//coordonnées de découpe.

    tempPos.w=decoupe.w=TAILLE_BLOCK;
    tempPos.h=decoupe.h=TAILLE_BLOCK;

    for(i=ligne;i>=0;i--)
    {
        for(j=0;j<NB_BLOCK_LARG;j++)
        {
            if (i)
            {
                tableau[j][i]=tableau[j][i-1];
                tempPos.x=decoupe.x=j*TAILLE_BLOCK + BOARDPOS;
                tempPos.y=i*TAILLE_BLOCK;
                decoupe.y=(i-1)*TAILLE_BLOCK;

                SDL_BlitSurface(ecran,&decoupe,ecran,&tempPos);
            }
            else
            {
                tableau[j][i]=false;
            }
        }
    }
}


void disp_next(SDL_Surface *ecran, S_piece *Spiece)
{//affiche la prochaine Spiece ***VALIDE***

    int i; //temporaires

    SDL_Rect tempPos;

    tempPos.x=NEXT_X+4*TAILLE_BLOCK;
    tempPos.y=NEXT_Y-TAILLE_BLOCK;
    tempPos.h=2*TAILLE_BLOCK;
    tempPos.w=4*TAILLE_BLOCK;

    //nettoyage de la zone d'affichage
    SDL_FillRect(ecran,&tempPos,SDL_MapRGB(ecran->format,0,0,0));

    tempPos.h=TAILLE_BLOCK;
    tempPos.w=TAILLE_BLOCK;

    for (i=0;i<4;i++)
    {//redessine la Spiece
        tempPos.x=NEXT_X+Spiece->pos[i].x*TAILLE_BLOCK;
        tempPos.y=NEXT_Y+Spiece->pos[i].y*TAILLE_BLOCK;

        SDL_BlitSurface(Spiece->carre,&Spiece->decoup,ecran,&tempPos);
    }
}


void disp_texte(SDL_Surface *ecran, char texte[], TTF_Font* police, SDL_Rect* position)
{//affiche les textes ***VALIDE***

    SDL_Color colorTxt={255,255,255,0};
    SDL_Surface *surf_text=NULL;
    SDL_Rect temp;

    if ((surf_text=TTF_RenderText_Solid(police,texte,colorTxt))==NULL)
    {//gestion de l'erreur
        printf("disp_text / Erreur de création de surf_text\n");
        exit(EXIT_FAILURE);
    }

    temp.x=position->x;
    temp.y=position->y;
    temp.h=surf_text->h+5;
    temp.w=surf_text->w+5;

    SDL_FillRect(ecran,position,SDL_MapRGB(ecran->format,0,0,0));//nettoyage de la zone d'affichage
    SDL_BlitSurface(surf_text,NULL,ecran,position);//application du text

    SDL_FreeSurface(surf_text);

}


void game_over(SDL_Surface* ecran, TTF_Font *police)
{//game over  ***VALIDE***

    int i=0, j=0;
    unsigned tempsAct;

    SDL_Rect tempPos;

    tempPos.h=TAILLE_BLOCK;
    tempPos.w=TAILLE_BLOCK;

    char gameOver[10];

    SDL_Color colorTxt={255,255,255,0};

    SDL_Surface *surf_gameOver=NULL;

    sprintf(gameOver,"GAME OVER");

    if ((surf_gameOver=TTF_RenderText_Solid(police,gameOver,colorTxt))==NULL)
    {//gestion de l'erreur
        printf("Err création du text game over : %s\n",SDL_GetError());
    }
    else
    {//execution.
        for(i=0;i<NB_BLOCK_HAUT;i++)
        {//disparition des blocs.
            tempPos.y=i*TAILLE_BLOCK;

            for (j=0;j<NB_BLOCK_LARG;j++)
            {

                tempPos.x=j*TAILLE_BLOCK;

                SDL_Delay(10);

                SDL_FillRect(ecran,&tempPos,SDL_MapRGB(ecran->format,0,0,0));

                SDL_Flip(ecran);
            }
        }

        tempPos.x=(TAILLE_BLOCK*NB_BLOCK_LARG-surf_gameOver->w)/2;
        tempPos.h=surf_gameOver->h;
        tempPos.w=surf_gameOver->w;

        for(i=0;i<=ecran->h/2;i+=5)
        {//descente du texte.
            tempPos.y=i;
            SDL_FillRect(ecran,&tempPos,SDL_MapRGB(ecran->format,0,0,0));
            SDL_BlitSurface(surf_gameOver,NULL,ecran,&tempPos);

            SDL_Delay(50);

            SDL_Flip(ecran);
        }

        tempsAct=SDL_GetTicks();

        while (tempsAct+5000>SDL_GetTicks())
            SDL_Delay(100);
    }
}

#include <iostream>
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include "constantes.h"



void init_input(struct S_input* Sinput)
{//initialisation des entrées.***VALIDE***

    Sinput->quit=false;

    for(int i=0;i<SDLK_LAST;i++)
    {
        Sinput->key[i]=false;

        if (i<8)
        {//mise à 0 des boutons souris.
            Sinput->mseBt[i]=false;
        }

        if (i<10)
        {//mise à 0 des boutons des pads.
            for(int j=0;j<2;j++)
                Sinput->padBt[j][i]=false;
        }

        if (i<8)
        {//mise à 0 des chapeaux des pads.
            for(int j=0;j<2;j++)
            {
                Sinput->padHat[j][i]=false;
            }
        }
    }

    Sinput->padRepet=200;//valeur de répetition des chapeaux.
    Sinput->btRepet=200;//valeur de répetition des boutons.
    Sinput->padRepetActTime=Sinput->btRepetActTime=SDL_GetTicks();
}


void get_input(struct S_global *Sglobal)
{//actualisation des entrées.***VALIDE***


    SDL_Event event;

    int i=0;

    //Reprise pour lecture
    S_input *Sinput=Sglobal->Sinput;
    SDL_Joystick *joy=NULL;


    //Reprise pour lecture
    if (Sglobal->Scontrol->joy!=NULL)
        joy=Sglobal->Scontrol->joy[Sglobal->Scontrol->numPad];


    while (SDL_PollEvent(&event))
    {
        switch (event.type)
        {
            case SDL_QUIT :
                Sinput->quit=true;
            break;

            case SDL_KEYDOWN :
                Sinput->key[event.key.keysym.sym]=true;
            break;

            case SDL_MOUSEBUTTONDOWN :
                Sinput->mseBt[event.button.button]=true;
            break;

            case SDL_JOYBUTTONDOWN :
                if (event.jbutton.which==Sglobal->Scontrol->numPad && Sglobal->Scontrol->modeControl)
                {
                    Sinput->padBt[ACT][1]=Sinput->padBt[PREV][1]=(event.jbutton.button==Sglobal->Scontrol->padBtDroite);
                    Sinput->padBt[ACT][0]=Sinput->padBt[PREV][0]=(event.jbutton.button==Sglobal->Scontrol->padBtGauche);
                    Sinput->btRepetActTime=SDL_GetTicks();
                }
            break;

            case SDL_JOYHATMOTION :

                switch (event.jhat.value)
                {

                    case SDL_HAT_UP :

                        if (event.jhat.which==Sglobal->Scontrol->numPad && Sglobal->Scontrol->modeControl)
                        {
                            Sinput->padHat[ACT][SDL_HAT_UP]=true;
                            Sinput->padHat[PREV][SDL_HAT_UP]=true;
                            Sinput->padRepetActTime=SDL_GetTicks();
                        }

                        break;

                    case SDL_HAT_DOWN :

                        if (event.jhat.which==Sglobal->Scontrol->numPad && Sglobal->Scontrol->modeControl)
                        {
                            Sinput->padHat[ACT][SDL_HAT_DOWN]=true;
                            Sinput->padHat[PREV][SDL_HAT_DOWN]=true;
                            Sinput->padRepetActTime=SDL_GetTicks();
                        }

                    break;

                    case SDL_HAT_LEFT :

                        if (event.jhat.which==Sglobal->Scontrol->numPad && Sglobal->Scontrol->modeControl)
                        {
                            Sinput->padHat[ACT][SDL_HAT_LEFT]=true;
                            Sinput->padHat[PREV][SDL_HAT_LEFT]=true;
                            Sinput->padRepetActTime=SDL_GetTicks();
                        }

                    break;

                    case SDL_HAT_RIGHT:

                        if (event.jhat.which==Sglobal->Scontrol->numPad && Sglobal->Scontrol->modeControl)
                        {
                            Sinput->padHat[ACT][SDL_HAT_RIGHT]=true;
                            Sinput->padHat[PREV][SDL_HAT_RIGHT]=true;
                            Sinput->padRepetActTime=SDL_GetTicks();
                        }

                    break;

                    case SDL_HAT_CENTERED :

                        //suppression de la mémorisation des fronts montants
                        for(i=0;i<10;i++)
                        Sinput->padHat[PREV][i]=false;

                    break;


                    default:
                    break;
                }

                default:
                break;
            }
    }

    if (joy!=NULL && Sglobal->Scontrol->modeControl)
    {//gestion du pad avec répétition
        switch (SDL_JoystickGetHat(joy,0))
        {//vérification du chapeau

            case SDL_HAT_UP :

                if (Sinput->padHat[PREV][SDL_HAT_UP] && SDL_GetTicks()> Sinput->padRepetActTime+Sinput->padRepet)
                {//control de l'état précedent du chapeau
                    Sinput->padHat[ACT][SDL_HAT_UP]=true;
                    Sinput->padRepetActTime=SDL_GetTicks();
                }

            break;

            case SDL_HAT_DOWN :

                if (Sinput->padHat[PREV][SDL_HAT_DOWN] && SDL_GetTicks()> Sinput->padRepetActTime+Sinput->padRepet)
                {//control de l'état précedent du chapeau

                    Sinput->padHat[ACT][SDL_HAT_DOWN]=true;
                    Sinput->padRepetActTime=SDL_GetTicks();
                }

            break;

            case SDL_HAT_LEFT :

                if (Sinput->padHat[PREV][SDL_HAT_LEFT] && SDL_GetTicks()> Sinput->padRepetActTime+Sinput->padRepet)
                {//control de l'état précedent du chapeau

                    Sinput->padHat[ACT][SDL_HAT_LEFT]=true;
                    Sinput->padRepetActTime=SDL_GetTicks();
                }

            break;

            case SDL_HAT_RIGHT :

                if (Sinput->padHat[PREV][SDL_HAT_RIGHT] && SDL_GetTicks()> Sinput->padRepetActTime+Sinput->padRepet)
                {//control de l'état précedent du chapeau

                    Sinput->padHat[ACT][SDL_HAT_RIGHT]=true;
                    Sinput->padRepetActTime=SDL_GetTicks();
                }

            break;

            default:
            break;
        }

        if (SDL_JoystickGetButton(joy,Sglobal->Scontrol->padBtGauche)
            && Sinput->padBt[PREV][0]
            && SDL_GetTicks()> Sinput->btRepetActTime+Sinput->btRepet )
        {//si bouton rotation gauche (prioritaire)

            Sinput->padBt[ACT][0]=true;
            Sinput->btRepetActTime=SDL_GetTicks();
        }

        else if (SDL_JoystickGetButton(joy,Sglobal->Scontrol->padBtDroite)
            && Sinput->padBt[PREV][1]
            && SDL_GetTicks()> Sinput->btRepetActTime+Sinput->btRepet)
        {//si bouton rotation droite

            Sinput->padBt[ACT][1]=true;
            Sinput->btRepetActTime=SDL_GetTicks();
        }
    }
}


int saisie_cfg(SDL_Surface *ecran,S_temp *Stemp)
{//saisie de configuration des touches ***VALIDE***

        /**** Déclarations ****/

    int i=0,//temp d'index
    retour=1;//valeur de retour de la fonction

    bool fin=false;//bit de fin de boucle

    char droiteTxt[35]="appuyer sur droite",
        gaucheTxt[35]="appuyer sur gauche";

//SDL

    SDL_Event event;

    SDL_Color colorTxt={255,255,255,0};//couleur du text

    //surface des textes.
    SDL_Surface *surf_txt=NULL;

    //position du texte.
    SDL_Rect textPos;
    textPos.x=150;
    textPos.y=250;


//TTF

    //ouverture de la police
    TTF_Font *police=TTF_OpenFont("font/comic.ttf",20);

    if(police==NULL)
    {//gestion de l'erreur.
        printf("saisie_Cfg / Err ouverture comic.ttf");
        fin=true;
        retour=0;
    }
    else
    {//création de la surface
        TTF_SetFontStyle(police,TTF_STYLE_NORMAL);

        if((surf_txt=TTF_RenderText_Solid(police,droiteTxt,colorTxt))==NULL)
        {
            printf("saisie_cfg / Err création de surface :%s",SDL_GetError());
            fin=true;
            retour=0;
        }
        else
        {
            textPos.h=surf_txt->h;
            textPos.w=surf_txt->w;
            SDL_FillRect(ecran,&textPos,SDL_MapRGB(ecran->format,0,0,0));//nettoyage de la zone d'affichage
            SDL_BlitSurface(surf_txt,NULL,ecran,&textPos);
        }
    }

    SDL_Flip(ecran);


    /***** Boucle Principale*****/

    while(!fin)
    {//boucle principale.
        SDL_WaitEvent(&event);

        if(event.type==SDL_QUIT)
        {//quitter
            retour=0;
            fin=true;
        }

        switch (Stemp->control)
        {//capture des controles.
            case 0:
            {//capture clavier.
                if(!i && event.type==SDL_KEYDOWN)
                {
                    Stemp->clavDroit=event.key.keysym.sym;
                    i++;
                }
                else if (i && event.type==SDL_KEYDOWN)
                {
                    Stemp->clavGauc=event.key.keysym.sym;
                    fin=true;
                }
            }
            break;

            case 1:
            {//capture pad.
                if (!i && event.type==SDL_JOYBUTTONDOWN && event.jbutton.which==Stemp->padNum)
                {
                    Stemp->btDroit=event.jbutton.button;
                    i++;
                }
                else if(i && event.type==SDL_JOYBUTTONDOWN && event.jbutton.which==Stemp->padNum)
                {
                    Stemp->btGauc=event.jbutton.button;
                    fin=true;
                }
            }
            break;

            default:
            break;
        }

        if (i)
        {//Basculement du texte.
            SDL_FreeSurface(surf_txt);
            SDL_FillRect(ecran,&textPos,SDL_MapRGB(ecran->format,0,0,0));//nettoyage de la zone d'affichage


            if((surf_txt=TTF_RenderText_Solid(police,gaucheTxt,colorTxt))==NULL)
            {//gestion d'erreur.
                printf("saisie_cfg / Err création de surface :%s",SDL_GetError());
                fin=true;
                retour=0;
            }

            SDL_BlitSurface(surf_txt,NULL,ecran,&textPos);
            SDL_Flip(ecran);
        }
    }

    /***** Sortie *****/

    SDL_FreeSurface(surf_txt);
    TTF_CloseFont(police);
    return(retour);
}

#include <iostream>
#include <SDL/SDL.h>
#include <SDL/fmod.h>
#include <stdio.h>
#include <stdlib.h>
#include "constantes.h"
#include "fichier.h"

void init_global(S_global *Sglobal)
{//initialisation de la strucure générale ***VALIDE***

    Sglobal->Sinput=new S_input;
    Sglobal->Sinfos=new S_infos;
    Sglobal->Sscore=new S_score;
    Sglobal->Scontrol=new S_control;
}


void libere_global_mem(S_global *Sglobal)
{//libération de la mémoire ***VALIDE***

    delete Sglobal->Scontrol->joy;
    delete Sglobal->Sinput;
    delete Sglobal->Sinfos;
    delete Sglobal->Sscore;
    delete Sglobal->Scontrol;
}


void init_infos(S_infos *Sinfos)
{//initialisations des infos globales ***VALIDE***

    Sinfos->fullscreen=false;
    Sinfos->hauteur=0;
    Sinfos->modeJoueur=0;
    Sinfos->vitesse=0;
    Sinfos->skin=0;
    Sinfos->tune=0;
}


void init_control(S_control *Scontrol)
{//initialisation des controles par défaut ***VALIDE***

    Scontrol->modeControl=0;
    Scontrol->numPad=0;
    Scontrol->padBtDroite=0;
    Scontrol->padBtGauche=1;
    Scontrol->clavierDroite=SDLK_w;
    Scontrol->clavierGauche=SDLK_q;
}


int lire_control(struct S_global *Sglobal)
{//lecture des infos de control dans le fichier ***VALIDE***

    FILE*fichier=fopen("data/control.dat","r");

    if (fichier==NULL)
    {//gestion d'erreur
        printf("Err ouverture de control.dat\n");
        return(0);
    }

    rewind(fichier);

    fscanf(fichier,"%d %d %d %d %d %d %d %d",&Sglobal->Scontrol->modeControl,
                                            &Sglobal->Scontrol->numPad,
                                            &Sglobal->Scontrol->padBtDroite,
                                            &Sglobal->Scontrol->padBtGauche,
                                            &Sglobal->Scontrol->clavierDroite,
                                            &Sglobal->Scontrol->clavierGauche,
                                            &Sglobal->Sinfos->skin,
                                            &Sglobal->Sinfos->tune);

    fclose(fichier);

    return(1);
}


int ecrire_control(struct S_global *Sglobal)
{//sauvegarde des infos de control dans le fichier ***VALIDE***

    FILE *fichier=fopen("data//control.dat","w");

    if (fichier==NULL)
    {//gestion d'erreur
        printf("Err ouverture de control.dat\n");
        return(0);
    }

    rewind(fichier);

    fprintf(fichier,"%d %d %d %d %d %d %d %d\n",Sglobal->Scontrol->modeControl,
                                                Sglobal->Scontrol->numPad,
                                                Sglobal->Scontrol->padBtDroite,
                                                Sglobal->Scontrol->padBtGauche,
                                                Sglobal->Scontrol->clavierDroite,
                                                Sglobal->Scontrol->clavierGauche,
                                                Sglobal->Sinfos->skin,
                                                Sglobal->Sinfos->tune);

    fclose(fichier);

    return(1);


}


int lire_score(struct S_score *Sscore)
{//lis le fichier des scores ***VALIDE***

    int i=0;
    FILE *fichier=fopen("data/scores.dat","r");

    if (fichier==NULL)
    {//gestion d'erreur
        printf("Err de chargement du fichier des scores.\n");
        return(0);
    }

    for(i=0;i<10;i++)
    {//lecture du fichier
        placerCurs(fichier,i);
        fgets(Sscore->score[i],20,fichier);
    }

    fclose(fichier);
    return(1);
}


int ecrire_score(struct S_score *Sscore)
{//ecris le fichier des scores ***VALIDE***

    int i=0;
    FILE *fichier=fopen("data/scores.dat","w");

    if (fichier==NULL)
    {//gestion d'erreur
        printf("Err de creation du fichier des scores.\n");
        return(0);
    }

    for(i=0;i<10;i++)
    {//ecriture du fichier
       fprintf(fichier,"%s",Sscore->score[i]);
    }

    fclose(fichier);
    return(1);

}


int init_score(struct S_score *Sscore)
{//initialise les scores en cas d'erreur d'ouverture du fichier scores ***VALIDE***

    int i=0;

    for(i=0;i<10;i++)
    {//remplissage des scores par défaut
        sprintf(Sscore->score[i],"aaa %d\n",10*i);
    }

    return(1);
}


int placerCurs(FILE *fichier, int ligne)
{//placement curseur dans fichier ***VALIDE***

    int i=0;
    rewind(fichier);
    char lettre='*';

    while (i<ligne && lettre!=EOF)
    {
        lettre=fgetc(fichier);

        if (lettre=='\n')
            i++;
    }
    return(ftell(fichier));
}


void pad_set (S_control *Scontrol)
{//attribution des pads branchés ***VALIDE***

    int i=0;

    Scontrol->joy=new SDL_Joystick*[SDL_NumJoysticks()];

    if (Scontrol->joy==NULL)
    {
        printf("Err reservation memoire\n");
        exit(EXIT_FAILURE);
    }

    for(i=0;i<SDL_NumJoysticks();i++)
    {
        Scontrol->joy[i]=SDL_JoystickOpen(i);
    }
}


void pad_reset (S_control *Scontrol)
{//libération des pads ***VALIDE***

    int i=0;

        for(i=0;i<SDL_NumJoysticks();i++)
        {
            SDL_JoystickClose(Scontrol->joy[i]);
        }
}


int compare_score(int score, S_score *Sscore)
{//détermine la position du score ***VALIDE***

    int i=9;

    if (score>=char_to_int(&Sscore->score[9][4]))
    {
        while (score>char_to_int(&Sscore->score[i][4]) && i>-1)
        {
            i--;
        }
    }
    else
        return(-2);


    return(i+1);
}


int char_to_int(const char text[])
{//transcodage char[] en int ***VALIDE***

    int i=0,//temporaire de boucle.
        exp=1,//poid du digit.
        result=0;//resultat.

    for(i=strlen(text)-2;i>=0;i--)
    {
        result+=(text[i]-48)*exp;
        exp=exp*10;
    }

    return (result);
}


void save_record(S_score *Sscore,char nom[],int rank,int score)
{//calage du nouveau score. ***VALIDE***

    int i=0;

    for (i=9;i>=rank;i--)
    {
        strcpy(Sscore->score[i],Sscore->score[i-1]);
    }

    sprintf(Sscore->score[rank],"%s %d\n",nom,score);
}


void switch_screen(SDL_Surface *ecran,S_global *Sglobal)
{//passage en fullscreen ***VALIDE***

    switch (Sglobal->Sinfos->fullscreen)
            {
                case false :
                {
                    SDL_FreeSurface(ecran);

                    ecran = SDL_SetVideoMode(TAILLE_BLOCK*NB_BLOCK_LARG+240, TAILLE_BLOCK*NB_BLOCK_HAUT, 32,SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN);

                    if (ecran==NULL)
                    {//defaut de creation de la fenetre.
                        printf("MAIN / Err init fenetre %s\n", SDL_GetError());
                        exit(EXIT_FAILURE);
                    }
                    Sglobal->Sinfos->fullscreen=true;
                }
                break;

                case true :
                {
                    SDL_FreeSurface(ecran);

                    ecran = SDL_SetVideoMode(TAILLE_BLOCK*NB_BLOCK_LARG+240, TAILLE_BLOCK*NB_BLOCK_HAUT, 32,SDL_HWSURFACE|SDL_DOUBLEBUF);

                    if (ecran==NULL)
                    {//defaut de creation de la fenetre.
                        printf("MAIN / Err init fenetre %s\n", SDL_GetError());
                        exit(EXIT_FAILURE);
                    }
                    Sglobal->Sinfos->fullscreen=false;
                }
                break;
            }
}


char *FSOUND_Err(int valeur)
{//transformation des erreurs FSOUND en text ***VALIDE***
    switch (valeur)
    {
        case FMOD_ERR_NONE :
            return ("no default");
            break;

        case FMOD_ERR_BUSY :
            return ("Cannot call this command after FSOUND_Init. Call FSOUND_Close first.");
            break;

        case FMOD_ERR_UNINITIALIZED :
            return ("This command failed because FSOUND_Init or FSOUND_SetOutput was not called");
            break;

        case FMOD_ERR_INIT:
            return("Error initializing output device.");
            break;

        case FMOD_ERR_ALLOCATED:
            return("Error initializing output device, the output device is already in use and cannot be reused");
            break;

        case FMOD_ERR_PLAY:
            return("Playing the sound failed");
            break;

        case FMOD_ERR_OUTPUT_FORMAT:
            return("Soundcard does not support the features needed for this soundsystem (16bit stereo output)");
            break;

        case FMOD_ERR_COOPERATIVELEVEL:
            return("Error setting cooperative level for hardware");
            break;

        case FMOD_ERR_CREATEBUFFER:
            return("Error creating hardware sound buffer");
            break;

        case FMOD_ERR_FILE_NOTFOUND:
            return("File not found");
            break;

        case FMOD_ERR_FILE_FORMAT:
            return("Unknown file format");
            break;

        case FMOD_ERR_FILE_BAD:
            return("Error loading file");
            break;

        case FMOD_ERR_MEMORY:
            return("Not enough memory or resources");
            break;

        case FMOD_ERR_VERSION:
            return("The version number of this file format is not supported");
            break;

        case FMOD_ERR_INVALID_PARAM:
            return("An invalid parameter was passed to this function");
            break;

        case FMOD_ERR_NO_EAX:
            return("Tried to use an EAX command on a non EAX enabled channel or output");
            break;

        case FMOD_ERR_CHANNEL_ALLOC:
            return("Failed to allocate a new channel");
            break;

        case FMOD_ERR_RECORD:
            return("Recording is not supported on this machine");
            break;

        case FMOD_ERR_MEDIAPLAYER:
            return("Windows Media Player not installed so cannot play wma or use internet streaming");
            break;

        case FMOD_ERR_CDDEVICE:
            return("An error occured trying to open the specified CD device");
            break;
    }

    return(NULL);
}