controleur.c

/*!
* \file controleur.c
* \brief Fichier contenant le code des fonctions du controleur.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "controleur.h"
#include "partie.h"
#include "joueur.h"
#include "joueurList.h"
#include "case.h"
#include "personnage.h"
#include "classe.h"
#include "gamePackage.h"
#include "roxml.h"
#include "deplacements.h"

Partie * partieGlobale;
Game_Package packGlobal;

  /*!
 * \fn void initJeu()
 * \brief La fonction initialise les variable globales du package du jeu et de la Partie
 */
void initJeu(){
    partieGlobale = initPartie();
    packGlobal = Construire_Package();
}

/*!
 * \fn void ajouterUnJoueur(char * nomDuJoueur, EtatsJeu * etat)
 * \brief Fonction ajoutant un Joueur à la Partie et faisant passer la partie à l'état suivant.
 *        Si le joueur n'a pas correctement été ajouté, l'état reste le même.
 *
 * \param Le nom du joueur à ajouter à la partie
 */
 void ajouterUnJoueur(char * nomDuJoueur, EtatsJeu * etat){
    Joueur * j = nouveauJoueur();
    if(j!=NULL){
        setNomJoueur(j,nomDuJoueur);
        if(addParticipant(partieGlobale,j)==1){
            *etat =LANCEMENT;
        }
        else{
            *etat=SAISIE_JOUEURS;
        }
    }
    else{
        *etat=SAISIE_JOUEURS;
    }
 }

 /*!
 * \fn int x_case_cliquee(int x_pixel, int y_pixel)
 * \brief La fonction retourne la colonne d'une case à partir de sa position en pixels
 *
 * \param les coordonnées x et y de la case en pixels
 * \return la colonne de la case
 */
int x_case_cliquee(int x_pixel, int y_pixel)
{
    return x_pixel/LARGEUR_CASE;
}
/*!
 * \fn int y_case_cliquee(int x_pixel, int y_pixel)
 * \brief La fonction retourne la ligne d'une case à partir de sa position en pixels
 *
 * \param les coordonnées x et y de la case en pixels
 * \return la ligne de la case
 */
int y_case_cliquee(int x_pixel, int y_pixel)
{
    int i, x_case, y_case;
    x_case = x_pixel/LARGEUR_CASE;
    y_case = y_pixel/HAUTEUR_CASE;
    for(i=1;i<LARGEUR_CARTE;i+=2)
    {
           if(x_case==i)
            {
                y_case=(y_pixel-HAUTEUR_CASE/2)/HAUTEUR_CASE;
            }
    }
    return y_case;
}


  /*!
 * \fn  int nbClasses()
 * \brief Fonction renvoyer le nombre de classes contenues dans le package du jeu
 *
 * \return le nombre de classes contenues dans le package du jeu
 */
 int nbClasses(){
    return getNbClasses(packGlobal);
}

 /*!
 * \fn char ** obtenirNomsClasses()
 * \brief Fonction renvoyant un tableau de chaine de caractères contenant les noms des Classes.
 *        L'ordre et l'index des noms dans le tableau correspond à l'ordre dans lequel ils sont définis
 *        dans le fichier XML.
 *
 * \return un tableau de chaine de charactères (char**).
 */
 char ** obtenirNomsClasses(){
    int i;
    //Allocation du tableau contenant les chaines de charactères
    char ** tabNomClasses=malloc(nbClasses()*sizeof(char[TAILLE_NOMS]));
    for(i=0;i<nbClasses();i++){
        tabNomClasses[i]= malloc(TAILLE_NOMS*sizeof(char));
    }
    //Copie des noms de classes dans le tableau
    for(i=0;i<nbClasses();i++){
        strncpy(tabNomClasses[i],packGlobal.Classes_Package[i].nom, TAILLE_NOMS);
    }
    return tabNomClasses;
 }

  /*!
 * \fn char ** obtenirSkinsClasses()
 * \brief Fonction renvoyant un tableau de chaine de caractères contenant le chemin vers les Skins des Classes.
 *        L'ordre et l'index des noms dans le tableau correspond à l'ordre dans lequel ils sont définis
 *        dans le fichier XML.
 *        Ici le chemin du Skin renvoyé est celui du "default".
 *
 * \return un tableau de chaine de charactères (char**).
 */
 char ** obtenirSkinsClasses(){
    int i;
    //Allocation du tableau contenant les chaines de charactères
    char ** tabSkinsClasses = malloc((getNbClasses(packGlobal))*sizeof(char *));
    for(i=0;i<getNbClasses(packGlobal);i++){
        tabSkinsClasses[i]= malloc(TAILLE_CHEMIN*sizeof(char));
    }
        //Copie des chemin des skins dans le tableau
    for(i=0;i<getNbClasses(packGlobal);i++){
        strncpy(tabSkinsClasses[i],packGlobal.Classes_Package[i].skins.charac_default, TAILLE_CHEMIN);
    }
    return tabSkinsClasses;
 }


   /*!
 * \fn void freeClasses()
 * \brief La fonction libère un tableau de chaines de charactères alloué pour stocker les informations sur les classes.
 *
 * \param
 */
  void freeClasses(char ** tab){
    int i;
    for(i=0;i<nbClasses();i++){
        free(tab[i]);
    }
    free(tab);
}

   /*!
 * \fn  int nbCartes()
 * \brief Fonction renvoyer le nombre de cartes contenues dans le package du jeu
 *
 * \return le nombre de cartes contenues dans le package du jeu
 */
int nbCartes(){
    return getNbCartes(packGlobal);
}

  /*!
 * \fn char ** obtenirNomsCartes()
 * \brief Fonction renvoyant un tableau de chaine de caractères contenant les noms des Cartes.
 *        L'ordre et l'index des noms dans le tableau correspond à l'ordre dans lequel ils sont définis
 *        dans le fichier XML.
 *
 * \return un tableau de chaine de charactères (char**).
 */
char ** obtenirNomsCartes(){
    int i;
    //Allocation du tableau contenant les chaines de charactères
    char ** tabNomsCartes = malloc((getNbCartes(packGlobal))*sizeof(char *));
    for(i=0;i<getNbCartes(packGlobal);i++){
        tabNomsCartes[i]= malloc(TAILLE_CHEMIN*sizeof(char));
    }
    //Copie des noms des cartes dans le tableau
    for(i=0;i<getNbCartes(packGlobal);i++){
        strncpy(tabNomsCartes[i],packGlobal.Cartes_Package[i].nom, TAILLE_CHEMIN);
    }
    return tabNomsCartes;
}

  /*!
 * \fn char ** obtenirDescriptionCarte()
 * \brief Fonction renvoyant un tableau de chaine de caractères contenant les descriptions des Cartes.
 *        L'ordre et l'index des descriptions dans le tableau correspond à l'ordre dans lequel ils sont définis
 *        dans le fichier XML.
 *
 * \return un tableau de chaine de charactères (char**).
 */
char ** obtenirDescriptionCarte(){
    int i;
    //Allocation du tableau contenant les chaines de caractères
    char ** tabDescCartes = malloc((getNbCartes(packGlobal))*sizeof(char *));
    for(i=0;i<getNbCartes(packGlobal);i++){
        tabDescCartes[i]= malloc(100*sizeof(char));
    }
    //Copie des descriptions des cartes dans le tableau
    for(i=0;i<getNbCartes(packGlobal);i++){
        strncpy(tabDescCartes[i],packGlobal.Cartes_Package[i].desc, 100);
    }
    return tabDescCartes;
}

  /*!
 * \fn void freeCartes()
 * \brief La fonction libère un tableau de chaines de charactères alloué pour stocker les informations sur la carte.
 *
 * \param le tableau de charactères à supprimmer.
 */
  void freeCartes(char ** tab){
    int i;
    for(i=0;i<nbCartes();i++){
        free(tab[i]);
    }
    free(tab);
}

/*!
 * \fn Case * trouverCase(Carte_Jeu * c, int x, int y)
 * \brief La fonction retourne un pointeur vers la case de coordonnées x,y
 *
 * \param les coordonnées x et y d'une case (pas en pixels mais bien en colonne et ligne), ainsi que la carte utilisée
 * \return un pointeur vers cette case
 */
Case * trouverCase(Carte_Jeu * c, int x, int y){
    if((x>=0)&&(x<LARG_MAX_CARTE)&&(y>=0)&&(y<HAUT_MAX_CARTE)){
       return &c->Tab_Cases[x][y];
    }
    return NULL;
}

  /*!
 * \fn int ajouterPersonnage(char * nomClasse, int numTab, int numJoueur)
 * \brief La fonction ajoute un personnage au tableau de personnages d'un Joueur à l'indice numTab(compris entre 0 et TAILLE_MAX_GROUPE).
 *        S'il y a déjà un personnage à l'indice numTab, l'ancien personnage est effacé du tableau.
 *
 * \param le nom de la classe dont dépend le Personnage, numTab un entier représentant l'indice auquel ajouter le Personnage dans le table de personnages,
 *        numJoueur est un entier représentant le premier ou le second Joueur de la Partie.
 * \return L'indice de la classe du personnage si le Personnage a été correctement ajouté, -1 sinon.
 */
int ajouterPersonnage(char * nomClasse, int numTab, int numJoueur){
    Personnage * p = NULL;
    int i;
    i=0;
    //Recherche de la classe dans le Package
    while(strcmp(nomClasse,getNomClasse(&packGlobal.Classes_Package[i]))!=0&&i<nbClasses()){
        i++;
    }
    if(i>=nbClasses()){
        return -1;
    }

    //Création du personnage
	p = default_personnage(i,packGlobal);

    //Ajout du Personnage à l'équipe du Joueur
    switch (numJoueur){
    case 1:
        setOnFirstJoueur(getListJoueur(partieGlobale));
        break;
    case 2:
        setOnFirstJoueur(getListJoueur(partieGlobale));
        nextJoueur(getListJoueur(partieGlobale));
        break;
    default:
        return -1;
    }

    if((numTab<TAILLE_MAX_GROUPE)&&(numTab>=0)){
        setNumero(p,numTab);
        addPersonnage(getCurrentJoueur(partieGlobale->participants),p,numTab);
        return i;
    }
    else{
        return -1;
    }
}

  /*!
 * \fn int selectionnerCarte(char * nomCarte)
 * \brief La fonction ajoute la Carte dont le nom est en parrametre à la Partie.
 *        Les Terrains de la Carte sont initialisé à partir des cartes décrites en XML
 *
 * \param Le nom de la Carte décrite en XML.
 * \return 1 si la carte est correctement initialisée, 0 sinon.
 */
int selectionnerCarte(char * nomCarte){
    int i;
    Game_Package copiePack = packGlobal;
    i=0;
    //Recherche de la Carte dans le Package
    while((strcmp(nomCarte,packGlobal.Cartes_Package[i].nom)!=0)&&(i<nbCartes())){
        i++;
    }

    if(i>=nbCartes()){
        return 0;
    }
    //Initialisation de la Carte_Jeu
    if(initCarte(&(copiePack.Cartes_Package[i]),getCarte(partieGlobale),&copiePack)==0){
        printf("erreur : la carte ne peut etre initialisee");
        return 0;
    }
    packGlobal=copiePack;
    return 1;
}

  /*!
 * \fn void initPositions()
 * \brief La fonction initialise les positions des personnages sur la Carte.
 *        La carte de jeu doit être initialisée avant l'appel à cette fonction.
 */
void initPositions(){
    // Positionnement des Personnages sur la Carte_Jeu.
    int i;

    setOnFirstJoueur(getListJoueur(partieGlobale));

    for(i=0;i<TAILLE_MAX_GROUPE;i++){
        setPosition(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),i),&partieGlobale->c->Tab_Cases[6+i][0]);
    }
    nextJoueur(getListJoueur(partieGlobale));
    for(i=0;i<TAILLE_MAX_GROUPE;i++){
        setPosition(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),i),&partieGlobale->c->Tab_Cases[6+i][HAUT_MAX_CARTE-1]);
    }
}

  /*!
 * \fn char * ObtenirRessourceTerrain(int x, int y)
 * \brief La fonction teste le type d'un Terrain aux coordonnées données et renvoie la ressource à afficher.
 *        L'utilisation de cette fonction pourrait se faire dans une boucle dans la SDL pour afficher la carte Case par Case.
 *        Il est d'abbord nécessaire de convertir les coordonnées "pixels" en coordonnées de cases de jeu.
 *        La carte doit être initialisées avant l'appel à cette fonction.
 *
 * \param Les coordonnées de la Case à tester
 * \return un char * vers la ressource du Terrain de la case.
 */
char * ObtenirRessourceTerrain(int x, int y){
    return get_terrain(trouverCase(getCarte(partieGlobale),x,y))->skin_default;
}

  /*!
 * \fn int personnagePresent(int x, int y)
 * \brief La fonction teste si un Personnage est présent aux coordonnées à tester.
 *        Les coordonnées doivent être convertir des "pixels" de la SDL en Cases de Jeu.
 *
 * \param Les coordonnées de la Case à tester
 * \return 1 si un Personnage est présent aux coordonnées, 0 sinon.
 */
int personnagePresent(int x, int y){
    return est_occupee(trouverCase(getCarte(partieGlobale),x,y));
}

  /*!
 * \fn char * obtenirRessourcePersonnage(int x, int y)
 * \brief La fonction renvoie la ressource d'un Personnage présent aux coordonnées.
 *
 * \param Les coordonnées de la Case à tester
 * \return la ressource du personnage sur la case, NULL s'il n'y a pas de personnage sur la case ou si le Personnage n'est pas trouvé.
 */
char * obtenirRessourcePersonnage(int x, int y){
    int i;
    Joueur * actuel = NULL;
    char * ressource = malloc(TAILLE_CHEMIN*sizeof(char));
    //Test Personnage sur la case.
    if(!personnagePresent(x,y)){
        return NULL;
    }

    else{
        //sauvegarde du Joueur dont c'est le tour.
        actuel = getCurrentJoueur(getListJoueur(partieGlobale));
        //recherche du Personnage sur la case pour le premier Joueur.
        setOnFirstJoueur(getListJoueur(partieGlobale));
        for(i=0;i<TAILLE_MAX_GROUPE;i++){
            if(get_x(getPosition(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),i)))==x){
                if(get_y(getPosition(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),i)))==y){
                    //sauvegarde de la ressource du Personnage.
                    ressource = (getClasse(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),i)))->skins.charac_default;
                    // On remet le pointeur courant sur le personnage dont c'est le tour.
                    setOnJoueur(getListJoueur(partieGlobale),actuel);
                    //retour de la ressource du personnage.
                    return ressource;
                }
            }
        }
        //recherche du Personnage sur la case pour le second Joueur.
        nextJoueur(getListJoueur(partieGlobale));
        for(i=0;i<TAILLE_MAX_GROUPE;i++){
            if(get_x(getPosition(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),i)))==x){
                if(get_y(getPosition(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),i)))==y){
                    ressource = (getClasse(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),i)))->skins.charac_default;
                    setOnJoueur(getListJoueur(partieGlobale),actuel);
                    return ressource;
                }
            }
        }
        //Si aucun personnage trouvé.
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return NULL;
    }
}

  /*!
 * \fn char * obtenirRessourcePersonnageNum(int numero)
 * \brief La fonction renvoie la ressource d'un Personnage dont le numero est celui définit dans la sdl.
 *
 * \param Le numero du personnage definit dans la sdl.
 * \return la ressource du personnage, NULL si le personnage n'est pas trouvé.
 */
char * obtenirRessourcePersonnageNum(int numero){
    Joueur * actuel = NULL;
    char * ressource = malloc(TAILLE_CHEMIN*sizeof(char));
    actuel = getCurrentJoueur(getListJoueur(partieGlobale));

    if ((numero>0)&&(numero<=3)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        strncpy(ressource,getClasse(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-1))->skins.charac_default,TAILLE_CHEMIN);
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return ressource;
    }
    else if ((numero>3)&&(numero<=6)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        nextJoueur(getListJoueur(partieGlobale));
        strncpy(ressource,getClasse(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-4))->skins.charac_default,TAILLE_CHEMIN);
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return ressource;
    }
    else{
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return NULL;
    }
}

  /*!
 * \fn void * obtenirPositionPersonnage(int numero, int * x, int * y)
 * \brief La fonction modifie les parrametres x et y en entrée en fonction des coordonnées du Personnage dont le numero en parrametre
 *        est celui définit dans la sdl.
 *
 * \param Le numero du personnage definit dans la sdl, des pointeurs vers des int x et y pour récupérer les coordonnées.
 */
void obtenirPositionPersonnage(int numero, int * x, int * y){
    Joueur * actuel = NULL;
    actuel = getCurrentJoueur(getListJoueur(partieGlobale));

    if ((numero>0)&&(numero<=3)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        *x=get_x(getPosition(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-1)));
        *y=get_y(getPosition(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-1)));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
    }
    else if ((numero>3)&&(numero<=6)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        nextJoueur(getListJoueur(partieGlobale));
        *x=get_x(getPosition(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-4)));
        *y=get_y(getPosition(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-4)));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
    }
}

  /*!
 * \fn Personnage * trouverPersonnage(Case * c)
 * \brief La fonction renvoie un pointeur vers le personnage présent sur la case en parametre.
 *
 * \param Les coordonnées de la Case à tester
 * \return Un pointeur vers un personnage, NULL, s'il n'y a pas de personnage sur la case.
 */
Personnage * trouverPersonnage(Case * c){
    int i;
    Personnage * resultat;
    resultat = NULL;
    Joueur * actuel = NULL;
    actuel = getCurrentJoueur(getListJoueur(partieGlobale));
    if(!est_occupee(c)){
        return resultat;
    }
    setOnFirstJoueur(getListJoueur(partieGlobale));
    for(i=0;i<TAILLE_MAX_GROUPE;i++){
        if(c==getPosition(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),i))){
            resultat = getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),i);
            setOnJoueur(getListJoueur(partieGlobale),actuel);
            return resultat;
        }
    }
    nextJoueur(getListJoueur(partieGlobale));
    for(i=0;i<TAILLE_MAX_GROUPE;i++){
        if(c==getPosition(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),i))){
            resultat = getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),i);
            setOnJoueur(getListJoueur(partieGlobale),actuel);
            return resultat;
        }
    }
    setOnJoueur(getListJoueur(partieGlobale),actuel);
    return NULL;
}


/*!
 * \fn void deplacement_personnage(int numPerso, int x_pixel, int y_pixel)
 * \brief La fonction permet de deplacer un personnage
 *
 * \param Le numero du personnage a deplacer, les coordonnees ou l'utilisateur a clique
 */
void deplacement_personnage(int numPerso, int x_pixel, int y_pixel){
    int x=x_case_cliquee(x_pixel, y_pixel);
    int y=y_case_cliquee(x_pixel, y_pixel);
    if(numPerso<=NB_PERSO){
        deplacement_unitaire(getCurrentJoueur(getListJoueur(partieGlobale))->groupe[numPerso-1],trouverCase(getCarte(partieGlobale),x,y));
    }
    else{
        deplacement_unitaire(getCurrentJoueur(getListJoueur(partieGlobale))->groupe[numPerso-1-NB_PERSO],trouverCase(getCarte(partieGlobale),x,y));
    }
}

/*!
 * \fn boolean case_accessible(int numPerso, int x_pixel, int y_pixel)
 * \brief fonction qui dit si une case distante est accessible a un personnage au vu de ses points de deplacements et du terrain
 *
 * \param Le numero du personnage a deplacer, les coordonnees ou l'utilisateur a clique
 * \return vrai ou faux
 */
boolean case_accessible(int numPerso, int x_pixel, int y_pixel){
    int x=x_case_cliquee(x_pixel, y_pixel);
    int y=y_case_cliquee(x_pixel, y_pixel);
    if(numPerso<=NB_PERSO){
        return deplacement_possible(getCurrentJoueur(getListJoueur(partieGlobale))->groupe[numPerso-1], trouverCase(getCarte(partieGlobale),x,y), getCarte(partieGlobale));
    }else{
        return deplacement_possible(getCurrentJoueur(getListJoueur(partieGlobale))->groupe[numPerso-1-NB_PERSO], trouverCase(getCarte(partieGlobale),x,y), getCarte(partieGlobale));
    }
}

  /*!
 * \fn char * obtenirNomJoueurCourant()
 * \brief La fonction renvoie le nom du Joueur dont c'est le tour.
 *
 * \return Un char * vers le nom du joueur dont c'est le tour.
 */
char * obtenirNomJoueurCourant(){
    return getNomJoueur(getCurrentJoueur(getListJoueur(partieGlobale)));
}

  /*!
 * \fn char * obtenirNomClassePersonnage(int numero)
 * \brief La fonction renvoie le nom de la classe du Personnage en parrametre.
 *        Le numero correspond au placement du personnage tel qu'il est défini dans la SDL et va de 1 à 6 :
 *        Exemples : Le Personnage 0 du joueur 2 dans le moteur correspond au numero 4 pour la SDL.
 *                   Le Personnage 1 du joueur 1 dans le moteur correspond au numero 2 pour la SDL.
 *
 * \param Le numero du personnage pour la SDL.
 * \return Un char * vers le nom de la classe du Personnage.
 */
char * obtenirNomClassePersonnage(int numero){
    Joueur * actuel = NULL;
    actuel = getCurrentJoueur(getListJoueur(partieGlobale));
    char * nomClasse;
    nomClasse = malloc(TAILLE_NOMS*sizeof(char));

    if ((numero>0)&&(numero<=3)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        strncpy(nomClasse, getNomClasse(getClasse(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-1))), TAILLE_NOMS);
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return nomClasse;
    }
    else if ((numero>3)&&(numero<=6)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        nextJoueur(getListJoueur(partieGlobale));
        strncpy(nomClasse, getNomClasse(getClasse(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-4))), TAILLE_NOMS);
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return nomClasse;
    }
    else{
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return NULL;
    }
}
  /*!
 * \fn int obtenirPVPersonnage(int numero)
 * \brief La fonction renvoie le PV du Personnage en parametre.
 *        Le numero correspond au placement du personnage tel qu'il est défini dans la SDL et va de 1 à 6 :
 *        Exemples : Le Personnage 0 du joueur 2 dans le moteur correspond au numero 4 pour la SDL.
 *                   Le Personnage 1 du joueur 1 dans le moteur correspond au numero 2 pour la SDL.
 *
 * \param Le numero du personnage pour la SDL.
 * \return Un int vers le PV du Personnage.
 */
int obtenirPVPersonnage(int numero){
    Joueur * actuel = NULL;
    actuel = getCurrentJoueur(getListJoueur(partieGlobale));
    int PVPersonnage = -1;

    if((numero>0)&&(numero<=3)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        PVPersonnage = get_PV(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-1));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return PVPersonnage;
    }

    else if ((numero>3)&&(numero<=6)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        nextJoueur(getListJoueur(partieGlobale));
        PVPersonnage = get_PV(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-4));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return PVPersonnage;
    }
    setOnJoueur(getListJoueur(partieGlobale),actuel);
    return PVPersonnage;
}

  /*!
 * \fn int obtenirPVMaxPersonnage(int numero)
 * \brief La fonction renvoie le PV max de la classe du Personnage en parametre.
 *        Le numero correspond au placement du personnage tel qu'il est défini dans la SDL et va de 1 à 6
 * \param Le numero du personnage pour la SDL.
 * \return Un int vers le PV max de la classe du Personnage.
 */
int obtenirPVMaxPersonnage(int numero){
    Joueur * actuel = NULL;
    actuel = getCurrentJoueur(getListJoueur(partieGlobale));
    int PVMaxPersonnage = -1;

    if((numero>0)&&(numero<=3)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        PVMaxPersonnage = getPVMax(getClasse(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-1)));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return PVMaxPersonnage;
    }

    else if ((numero>3)&&(numero<=6)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        nextJoueur(getListJoueur(partieGlobale));
        PVMaxPersonnage = getPVMax(getClasse(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-4)));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return PVMaxPersonnage;
    }
    setOnJoueur(getListJoueur(partieGlobale), actuel);
    return PVMaxPersonnage;
}
  /*!
 * \fn int obtenirManaPersonnage(int numero)
 * \brief La fonction renvoie le mana du Personnage en parametre.
 *        Le numero correspond au placement du personnage tel qu'il est défini dans la SDL et va de 1 à 6
 * \param Le numero du personnage pour la SDL.
 * \return Un int vers le mana du Personnage.
 */
int obtenirManaPersonnage(int numero){
    Joueur * actuel = NULL;
    actuel = getCurrentJoueur(getListJoueur(partieGlobale));
    int ManaPersonnage = -1;

    if((numero>0)&&(numero<=3)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        ManaPersonnage = get_mana(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-1));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return ManaPersonnage;
    }

    else if ((numero>3)&&(numero<=6)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        nextJoueur(getListJoueur(partieGlobale));
        ManaPersonnage = get_mana(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-4));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return ManaPersonnage;
    }
    setOnJoueur(getListJoueur(partieGlobale), actuel);
    return ManaPersonnage;
}
  /*!
 * \fn int obtenirManaMaxPersonnage(int numero)
 * \brief La fonction renvoie le mana max de la classe du Personnage en parametre.
 *        Le numero correspond au placement du personnage tel qu'il est defini dans la SDL et va de 1 à 6
 * \param Le numero du personnage pour la SDL.
 * \return Un int vers le mana max de la classe du Personnage.
 */
int obtenirManaMaxPersonnage(int numero){
    Joueur * actuel = NULL;
    actuel = getCurrentJoueur(getListJoueur(partieGlobale));
    int ManaMaxPersonnage = -1;

    if((numero>0)&&(numero<=3)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        ManaMaxPersonnage = getManaMax(getClasse(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)), numero-1)));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return ManaMaxPersonnage;
    }

    else if ((numero>3)&&(numero<=6)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        nextJoueur(getListJoueur(partieGlobale));
        ManaMaxPersonnage = getManaMax(getClasse(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)), numero-4)));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return ManaMaxPersonnage;
    }
    setOnJoueur(getListJoueur(partieGlobale), actuel);
    return ManaMaxPersonnage;
}
  /*!
 * \fn int obtenirPDPersonnage(int numero)
 * \brief La fonction renvoie le PD du Personnage en parametre.
 *        Le numero correspond au placement du personnage tel qu'il est defini dans la SDL et va de 1 à 6
 * \param Le numero du personnage pour la SDL.
 * \return Un int vers le PD du Personnage.
 */
int obtenirPDPersonnage(int numero){
    Joueur * actuel = NULL;
    actuel = getCurrentJoueur(getListJoueur(partieGlobale));
    int PDPersonnage = -1;

    if((numero>0)&&(numero<=3)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        PDPersonnage = get_PD(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-1));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return PDPersonnage;
    }

    else if ((numero>3)&&(numero<=6)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        nextJoueur(getListJoueur(partieGlobale));
        PDPersonnage = get_PD(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-4));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return PDPersonnage;
    }
    setOnJoueur(getListJoueur(partieGlobale), actuel);
    return PDPersonnage;
}
  /*!
 * \fn int obtenirPDMaxPersonnage(int numero)
 * \brief La fonction renvoie le PD max de la classe du Personnage en parametre.
 *        Le numero correspond au placement du personnage tel qu'il est défini dans la SDL et va de 1 à 6
 * \param Le numero du personnage pour la SDL.
 * \return Un int vers le PD max de la classe du Personnage.
 */
int obtenirPDMaxPersonnage(int numero){
    Joueur * actuel = NULL;
    actuel = getCurrentJoueur(getListJoueur(partieGlobale));
    int PDMaxPersonnage = -1;

    if((numero>0)&&(numero<=3)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        PDMaxPersonnage = getPDMax(getClasse(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-1)));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return PDMaxPersonnage;
    }

    else if ((numero>3)&&(numero<=6)){
        setOnFirstJoueur(getListJoueur(partieGlobale));
        nextJoueur(getListJoueur(partieGlobale));
        PDMaxPersonnage = getPDMax(getClasse(getPersonnage(getCurrentJoueur(getListJoueur(partieGlobale)),numero-4)));
        setOnJoueur(getListJoueur(partieGlobale),actuel);
        return PDMaxPersonnage;
    }
    setOnJoueur(getListJoueur(partieGlobale), actuel);
    return PDMaxPersonnage;
}

  /*!
 * \fn char ** obtenirNomsAttaquesPersonnage()
 * \brief Fonction renvoyant un tableau de chaine de caractères contenant les noms des attaques des personnages.
 *        L'ordre et l'index des descriptions dans le tableau correspond à l'ordre dans lequel ils sont définis
 *        dans le fichier XML.
 *
 * \return un tableau de chaine de charactères (char**).
 */
/*char ** obtenirNomsAttaquesPersonnage(int numero){
    int i;
    char ** tabNomsAttPerso = malloc(NB_ATTAQUES_MAX * sizeof(char *));
    for(i=0;i<NB_ATTAQUES_MAX;i++){
        tabNomsAttPerso[i]= malloc(TAILLE_NOMS*sizeof(char));
    }
    if((numero>0) && (numero<=3)){
       for(i=0;i<NB_ATTAQUES_MAX;i++){
        strncpy(tabNomsAttPerso[i],packGlobal.Classes_Package->attaques->nom, TAILLE_NOMS);
       }
    }
    else if ((numero>3)&&(numero>6)){
        strncpy(tabNomsAttPerso[i],packGlobal.Classes_Package->attaques->nom, TAILLE_NOMS);
    }
    return tabNomsAttPerso;
}*/

  /*!
 * \fn void debutDuTour()
 * \brief La fonction effectue les opération de début de tour.
 *        Les points de déplacements des personnages sont remis au maximum
 *        Les Personnages récupèrent une partie de leur mana.
 *        Note : Pour l'instant, les personnages récupère 10% de leur mana total au début du tour.
                 (Ils ne peuvent pas avoir un mana supérieur à leur mana maximum définit par la classe.)
 *               Si vous voulez changer ça, dites moi.
 */
void debutDuTour(){
    debutTour(partieGlobale);
}

  /*!
 * \fn int finDuTour()
 * \brief La fonction teste si un Joueur est victorieux et sinon termine le tour du Joueur actuel.
 *
 * \return 1 si un joueur a remporté la partie, 0 sinon, dans ce cas, la main est donnée au joueur suivant.
 */
int finDuTour(){
    // La fin du tour est possible si la partie n'est pas gagnée par un Joueur
    return finTour(partieGlobale);
}

void personnageSuivant();

  /*!
 * \fn char * joueurVictorieux()
 * \brief La fonction retourne le nom du Joueur qui a remporté la partie.
 *        Cette fonction doit être appellée seulement si la fonction finDuTour a renvoyé 1.
 *        Sinon la fonction renvoie seulement le nom du joueur dont c'est le tour.
 *
 * \return Une chaine de caractère vers le nom d'un Joueur.
 */
char * joueurVictorieux(){
    return getNomJoueur(getCurrentJoueur(getListJoueur(partieGlobale)));
}

// Je met ici mes tests réalisés dans le main pour éviter de les réécrire si jamais il y a un problème.
// Si vous voulez tester aussi, à recopier dans le main avant l'appel à initJeu().
void testControlleurConsole(){
    int i,j,n,x,y;
    EtatsJeu state = SAISIE_JOUEURS;
    extern Partie * partieGlobale;
    extern Game_Package packGlobal;
    initJeu();
    ajouterUnJoueur("Joueur1",&state);
    ajouterUnJoueur("Joueur2",&state);

    ajouterPersonnage(packGlobal.Classes_Package[0].nom,0,1);
    ajouterPersonnage(packGlobal.Classes_Package[1].nom,1,1);
    ajouterPersonnage(packGlobal.Classes_Package[2].nom,2,1);
    ajouterPersonnage(packGlobal.Classes_Package[3].nom,0,2);
    ajouterPersonnage(packGlobal.Classes_Package[4].nom,1,2);
    ajouterPersonnage(packGlobal.Classes_Package[0].nom,2,2);

    selectionnerCarte(packGlobal.Cartes_Package[2].nom);
    initPositions();


    for(i=0;i<LARG_MAX_CARTE;i++){
        for(j=0;j<HAUT_MAX_CARTE;j++){
            printf("%s\n",ObtenirRessourceTerrain(i,j));
        }
    }

    for(i=0;i<LARG_MAX_CARTE;i++){
        for(j=0;j<HAUT_MAX_CARTE;j++){
            printf("%d ",personnagePresent(i,j));
        }
        printf("\n");
    }

    for(i=0;i<LARG_MAX_CARTE;i++){
        for(j=0;j<HAUT_MAX_CARTE;j++){
            if(personnagePresent(i,j)){
                printf("Position : %d/%d\n%s\n",i,j,obtenirRessourcePersonnage(i,j));
                /* Attention  pour ce qui suit: l'acces aux informations sera moins "compliqué" hors des tests
                car la SDL "connait" le numero quelle a attribuée aux personnages.
                Ici, c'était une manière de simuler l'acces aux données mais depuis le moteur.
                */
                if((appartientJoueur(trouverPersonnage(getCase(getCarte(partieGlobale),i,j)),partieGlobale))==(getListJoueur(partieGlobale)->firstNodeJoueur->j)){
                    n=1+getIndicePersonnage((getListJoueur(partieGlobale)->firstNodeJoueur->j),trouverPersonnage(getCase(getCarte(partieGlobale),i,j)));
                }
                else{
                    n=4+getIndicePersonnage((getListJoueur(partieGlobale)->lastNodeJoueur->j),trouverPersonnage(getCase(getCarte(partieGlobale),i,j)));
                }
                obtenirPositionPersonnage(n,&x,&y);
                printf("Position : %d:%d\n",x,y);
                printf("%s\n", obtenirNomClassePersonnage(n));
                printf("%s\n", obtenirRessourcePersonnageNum(n));
                printf("%d\n", obtenirPVPersonnage(n));
                printf("%d\n", obtenirPVMaxPersonnage(n));
                printf("%d\n", obtenirManaPersonnage(n));
                printf("%d\n", obtenirManaMaxPersonnage(n));
                printf("%d\n", obtenirPDPersonnage(n));
                printf("%d\n", obtenirPDMaxPersonnage(n));
            }
        }
    }

}