Skip to content
Snippets Groups Projects
Select Git revision
  • master default protected
1 result
Blame Permalink
structures.h 9.60 KiB 
/*! \file structures.h
 * \brief Fichier contenant les principales structures.
 * Definition des structures necessaires :
 * SOMMAIRE
 * Type_terrain
 * Case
 * Attaque
 * Classe
 * Personnage
 * Effet
 * Competence
 * Joueur
 * NodeJoueur
 * ListJoueur
 * Partie
 */

#ifndef STRUCTURES_H_INCLUDED
#define STRUCTURES_H_INCLUDED

/*! \def TAILLE_MAX_CARTE */
#define TAILLE_MAX_CARTE 160
/*! \def TAILLE_MAX_LIGNE */
#define TAILLE_MAX_LIGNE 25
/*! \def TAILLE_ID */
#define TAILLE_ID 20
/*! \def TAILLE_NOMS */
#define TAILLE_NOMS 25
/*! \def TAILLE_MAX_GROUPE */
#define TAILLE_MAX_GROUPE 3
/*! \def LARG_MAX_CARTE */
#define LARG_MAX_CARTE 16
/*! \def LONG_MAX_CARTE */
#define HAUT_MAX_CARTE 10
/*! \def TAILLE_CHEMIN */
#define TAILLE_CHEMIN 50

/*! \enum boolean
 * \brief Definition du type Boolean.
 *
 * faux=0, vrai=1
 */
typedef enum {faux, vrai} boolean;

/*! \enum boolean
 * \brief Definition du type EtatsJeu.
 */
 /*
  * Les états du jeu sont basés sur le scénarion définit dans la documentation.
  * Il y en a éventuellement à ajouter ou à supprimer.
  * Je pense notament aux états JxPy attaque ou deplacement.
  * Il me semble que c'est un état différent à chaque fois, mais peut être qu'on peut
  * tout réunir dans l'état TOUR_JxPy. Dites moi ce que vous en pensez.
  * En tout cas les premiers états jusqu'à CONFIGURATION devraient permettre de rendre la V2.
  */
typedef enum    {SAISIE_JOUEURS,
                LANCEMENT,
                CONFIGURATION,
                TOUR_J1P1,
                J1P1_DEPLACEMENT,
                J1P1_ATTAQUE,
                TOUR_J1P2,
                J1P2_DEPLACEMENT,
                J1P2_ATTAQUE,
                TOUR_J1P3,
                J1P3_DEPLACEMENT,
                J1P3_ATTAQUE,
                TOUR_J2P1,
                J2P1_DEPLACEMENT,
                J2P1_ATTAQUE,
                TOUR_J2P2,
                J2P2_DEPLACEMENT,
                J2P2_ATTAQUE,
                TOUR_J2P3,
                J2P3_DEPLACEMENT,
                J2P3_ATTAQUE,
                VICTOIRE,
                FERMER
                }EtatsJeu;

/*! \struct Skins_Charac structures.h
 * \brief Definition de la structure Skins_Charac
 * sizeof(Skins_Charac) = 200 octets
 * Ensemble de noms de fichiers indiquant les textures des personnages
 */
 typedef struct Skins_Charac{
    char charac_default[50];
    char charac_selected[50];
    char charac_healed[50];
    char charac_damaged[50];
} Skins_Charac;

 typedef struct Skins_GUI{
    char id[50];
    char GUI_default[50];
} Skins_GUI;


/*! \struct Type_terrain structures.h
 * \brief Definition de la structure Type_terrain
 * sizeof(Terrain) = 28 octets
 */
typedef struct Terrain{
    char nomTerrain[TAILLE_NOMS];/*!< Nom du terrain. */
    boolean franchissable;/*!< Le terrain est franchissable ou non par un personnage. */
    boolean franchissable_sorts;/*!< Le terrain est franchissable ou non par un sort. */
    unsigned short int PD_requis;/*!< Nombre de PD requis pour traverser le terrain. */
    char skin_default[50];
}Terrain;

/*! \struct Case structures.h
 * \brief Definition de la structure Case
 * sizeof(Case) = 12 octets
 */
typedef struct Case{
    unsigned short int coord_x; /*!< Abscisse de la case*/
    unsigned short int coord_y; /*!< Ordonnee de la case*/
    Terrain * terrain; /*!< Le type de terrain de la case*/
    boolean occupee; /*!< La case est occupee ou non par un personnage*/
} Case;

/*! \typedef Carte structures.h
 * \brief Definition du type Carte_Jeu
 * La Carte_Jeu est composée d'un identifiant et d'un tableau de Case à deux entrées.
 */
typedef struct Carte_Jeu{
    char id[TAILLE_ID]; /*!< ID de la Carte_Jeu de taille TAILLE_ID*/
    Case Tab_Cases[LARG_MAX_CARTE][HAUT_MAX_CARTE];/*!< Double tableau de Case de largeur LARG_MAX_CARTE et de hauteur HAUT_MAX_CARTE*/
}Carte_Jeu;

/*! \typedef Carte structures.h
 * \brief Definition du type Carte
 * sizeof(Carte) = 3072 octets
 * La carte est un tableau de Case de taille TAILLE_MAX_CARTE.
 */
typedef Case Carte[TAILLE_MAX_CARTE];

/*! \struct Effet structures.h
 * \brief Definition de la structure Effet.
 * sizeof(Effet) = 48 octets
 */
typedef struct Effet{
    char id[TAILLE_ID]; /*!< ID de l'effet de taille TAILLE_ID*/
    char nom[TAILLE_NOMS]; /*!< Nom de l'effet de taille TAILLE_NOMS*/
    unsigned int nb_tours;/*!< Le nombre de tours restant avant que l'effet ne s'estompe*/
    unsigned int valeur_degats; /*!< Le nombre de degats subis */
    unsigned int valeur_soin; /*!< Le nombre PV regeneres */
    unsigned int valeur_degats_duree; /*!< Le nombre de degats de duree subis par tour*/
    unsigned int valeur_soin_duree; /*!< Le nombre PV regeneres par tour*/
    unsigned int paralysie; /*!< L'effet provoque ou non une paralysie*/
} Effet;

/*! \struct Attaque structures.h
 * \brief Definition de la structure Attaque.
 sizeof(Attaque) = 268 octets
 */
typedef struct Attaque{
    char id[TAILLE_ID];
    char nom[TAILLE_NOMS]; /*!< Nom de l'attaque de taille TAILLE_NOMS*/
    unsigned short int mana;
    unsigned short int portee; /*!< Portee en nombre de cases de l'attaque*/
    Effet effets[5]; /*!< Tableau des effets appliques par l'attaque, cela comprend les dégâts de duree*/
} Attaque;

/*! \struct Classe structures.h
 * \brief Definition de la structure Classe.
 * sizeof(Classe) = 1576 octets
 */
typedef struct Classe{
    char nom[25]; /*!< Nom de la classe de taille TAILLE_NOMS*/
    Attaque attaques[5]; /*!< Les attaques disponibles pour la classe*/
    unsigned short int points_deplacement_max; /*!< Les PD maximums accordés a la classe*/
    unsigned short int PV_max; /*!< Les PV maximums accordés a la classe*/
    unsigned short int mana_max; /*!< Le mana maximum accordé a la classe*/
    Skins_Charac skins;
}Classe;

/*! \struct Personnage structures.h
 * \brief Definition de la structure Personnage.
 * sizeof(Personnage) = 32 octets
 */
typedef struct Personnage{
    char nomPersonnage[TAILLE_NOMS];/*!< Nom du personnage de taille TAILLE_NOMS*/
    Classe* classe; /*!< La classe dont depend le personnage */
    unsigned short int points_deplacement; /*!< Les PD actuels du personnage*/
    unsigned short int PV; /*!< Les PV actuels du personnage*/
    unsigned short int mana; /*!< Le mana actuel du personnage*/
    Case *position; /*!< La case representant la position actuelle du personnage*/
    Effet effets[]; /*!< Un tableau d'effets representant les effets affectant le personnage*/
} Personnage;

/*! \struct Competence structures.h
 * \brief Definition de la structure competence.
 * sizeof(Competence) = 44 octets
 */


typedef struct Competence{
    char nomComp[TAILLE_NOMS]; /*!< Nom de la competence de taille TAILLE_NOMS*/
    char id[TAILLE_ID];   /*!< Un entier qui represente la competence*/
    unsigned int prix_competence; /*!< Points a depenser pour acquerir la competence */
    struct Competence *enfant; /*!< Premier enfant de la competence */
    struct Competence *frere; /*!< Competence suivante sur le meme niveau */
    struct Effet_Competence *effet;  /*!< Pointeur vers les effets de la competence */
    unsigned int connu; /*!< La competence est connue ou non */
}Competence;


/*! \struct Effet_Competence structures.h
 * \brief Definition de la structure Effet_Competence
 * sizeof(Effet_Competence) = 18 octets
 */
typedef struct Effet_Competence{
    unsigned short int id; /*!< Un entier qui represente la competence*/
    char nom[TAILLE_NOMS]; /*!< Nom de la competence de taille TAILLE_NOMS*/
/* ........ */
} Effet_Competence;


typedef struct Carte_A{
    char id[TAILLE_ID];
    char nom[50];
    char desc[100];
    char lignes[LARG_MAX_CARTE+1][HAUT_MAX_CARTE+1];
} Carte_A;



/*! \struct Classe structures.h
 * \brief Definition de la structure Game_Package
 * sizeof(Classe) =
 */
typedef struct Game_Package{
    int nbCartes;
    int nbClasses;
    Classe* Classes_Package;
    Terrain* Terrains_Package;
    Skins_GUI* GUI_Package;
    Carte_A* Cartes_Package;
    Competence* Competences_Package;
}Game_Package;



/*! \struct Joueur structures.h
 * \brief Definition de la structure Joueur
 *
 * Un Joueur est compose principalement d'un nom et d'un tableau de Personnages.
 * Il reste a ajouter des attributs tels que l'arbre de competence.
 * sizeof(Joueur) = 28 octets
 */
 typedef struct Joueur{
    char nomJoueur[TAILLE_NOMS]; /*!< Le nom identifiant le Joueur*/
    Personnage * groupe[TAILLE_MAX_GROUPE];/*!< Les personnages du joueur qui prennent part à la partie.*/
 } Joueur;

 /*! \struct NodeJoueur structures.h
 * \brief Definition de la structure NodeJoueur
 * sizeof(NodeJoueur) = 8 octets
 * NodeJoueur est un noeud defini pour gerer une liste de Joueur
 */
 typedef struct NodeJoueur{
    Joueur * j; /*!< valeur du noeud*/
    struct NodeJoueur * next;/*!< Pointeur vers le noeud suivant*/
 } NodeJoueur;

/*! \struct ListJoueur structures.h
 * \brief Definition de la structure ListJoueur
 * sizeof(ListJoueur) = 12 octets
 * ListJoueur est une liste de noeuds pointant vers des Joueur
 */
 typedef struct ListJoueur{
    NodeJoueur * firstNodeJoueur; /*!<Premier noeud*/
    NodeJoueur * currentNodeJoueur; /*!<Noeud courant*/
    NodeJoueur * lastNodeJoueur; /*!<Dernier noeud*/
 }ListJoueur;





 /*! \struct Partie structures.h
 * \brief Definition de la structure Partie
 *
 * Contient les informations concernant la partie telles que la liste des joueurs participants
 * le nombre de tours. Cette structure permet de gérer les tours
 * Peut eventuellement contenir l'information Carte si c'est utile.
 * sizeof(Partie) = 12 octets
 */

typedef struct Partie{
    ListJoueur * participants; /*!< La liste de joueurs prennant parts à la partie*/
    int nbTours; /*!<Le nombre de tours actuel*/
    Carte_Jeu * c; /*!<La Carte associee a la Partie*/
 }Partie;

#endif