IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C++ Discussion :

structure et class


Sujet :

C++

  1. #21
    Membre éclairé Avatar de devdeb91
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2013
    Messages
    246
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Janvier 2013
    Messages : 246
    Par défaut
    alors voila suite au lien donné http://cpp.developpez.com/faq/cpp/?p...erence_croisee j'ai suivi le meme exemple

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    #ifndef PERSONNAGE_H_INCLUDED
    #define PERSONNAGE_H_INCLUDED
    #include "main.h"
    #include <string>
    //#include "monstre.h"
    //#include "arme.h"
     
    class monstre;
     
    class personnage
    {
        private:
     
            monstre * ptrmonstre;
            int m_hp;
            int m_pm;
            int m_xp;
            int m_or;
            //arme m_arme;
     
        public:
     
            personnage();
            ~personnage();
            void recevoir_degats(int nombre_degats);
            //void soin(int nombre_soin);
            void attaquer(monstre &cible);
            //void magie(personnage &cible);
            //void objet(std::string nom);
            bool est_vivant();
            void recevoir_gain(int xp, int argent);
     
     
    };
     
    /*class monstre
    {
        private:
     
            std::string m_nom;
            int m_hp;
            int m_mp;
            std::string m_type;
            int m_xp;
            int m_argent;
     
        public:
     
            monstre(std::string nom, int hp, int mp, std::string type, int xp, int argent):m_nom(nom), m_hp(hp), m_mp(mp),
                m_type(type), m_xp(xp), m_argent(argent){}
            ~monstre()
            {
     
            }
            void attaquer(personnage &cible)
            {
                cible.recevoir_degats(50);
            }
            void recevoir_degats(int nbdegats)
            {
                m_hp -= nbdegats;
                if(m_hp < 0)
                    m_hp = 0;
            }
            bool est_vivant()
            {
     
                if(m_hp > 0)
                    return true;
                else
                    return false;
            }
    };
    */
     
    #endif // PERSONNAGE_H_INCLUDED
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    #include "personnage.h"
    #include "monstre.h"
     
    personnage(): m_hp(1000), m_pm(20), m_xp(0), m_or(500)
    {
     
    }
    personnage::~personnage()
    {
     
    }
    void personnage::recevoir_degats(int nombre_degats)
    {
        m_hp -= nombre_degats;
                if(m_hp < 0)
                    m_hp = 0;
    }
    void personnage::attaquer(monstre &cible)
    {
        cible.recevoir_degats(15);
    }
    bool personnage::est_vivant()
    {
        if(m_hp > 0)
                    return true;
                else
                    return false;
    }
    void personnage::recevoir_gain(int xp, int argent)
    {
         m_xp = m_xp + xp;
         m_or = m_or + argent;
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    #ifndef MONSTRE_H_INCLUDED
    #define MONSTRE_H_INCLUDED
    #include <string>
    #include "main.h"
    #include "personnage.h"
     
     
    class monstre
    {
        private:
     
            personnage ptrperso;
            std::string m_nom;
            int m_hp;
            int m_mp;
            std::string m_type;
            int m_xp;
            int m_argent;
     
        public:
     
            monstre(std::string nom, int hp, int mp, std::string type, int xp, int argent);
            ~monstre();
            void attaquer(personnage &cible);
            void recevoir_degats(int nbdegats);
            bool est_vivant();
    };
     
    #endif
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    #include "monstre.h"
     
    monstre::monstre(std::string nom, int hp, int mp, std::string type, int xp, int argent):m_nom(nom), m_hp(hp), m_mp(mp),
                m_type(type), m_xp(xp), m_argent(argent)
    {
     
    }
    monstre::~monstre()
    {
     
    }
    void monstre::attaquer(personnage &cible)
    {
        cible.recevoir_degats(50);
    }
    void monstre::recevoir_degats(int nbdegats)
    {
          m_hp -= nbdegats;
                if(m_hp < 0)
                    m_hp = 0;
    }
    bool monstre::est_vivant()
    {
        if(m_hp > 0)
                    return true;
                else
                    return false;
    }
    et les erreurs sont les meme les voici

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    C:\Users\kevin\Desktop\jeu2\monstre.h|12|error: 'personnage' does not name a type|
    C:\Users\kevin\Desktop\jeu2\monstre.h|24|error: 'personnage' has not been declared|
    C:\Users\kevin\Desktop\jeu2\personnage.cpp|4|error: expected unqualified-id before ')' token|
    ||=== Build finished: 3 errors, 0 warnings (0 minutes, 4 seconds) ===|
    donc meme avec cette façon la il n'y arrive pas

  2. #22
    Membre émérite

    Homme Profil pro
    Non disponible
    Inscrit en
    Décembre 2012
    Messages
    478
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Non disponible

    Informations forums :
    Inscription : Décembre 2012
    Messages : 478
    Billets dans le blog
    1
    Par défaut
    #include "monstre.h" ne doit pas être dans ton personnage.cpp il doit être dans ton personnage.h (tu l'as bien fait avec monstre ^^)

  3. #23
    Membre éclairé Avatar de devdeb91
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2013
    Messages
    246
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Janvier 2013
    Messages : 246
    Par défaut
    bah dans la FAQ c'est pas dis sa personnage est A et monstre B mais bon je vais essayer.

    edit : c'est toujours pareil il ne reconnait pas personnage

  4. #24
    Membre émérite

    Homme Profil pro
    Non disponible
    Inscrit en
    Décembre 2012
    Messages
    478
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Non disponible

    Informations forums :
    Inscription : Décembre 2012
    Messages : 478
    Billets dans le blog
    1
    Par défaut
    C'est qu'ici tu utilise ton monstre dans ton header

  5. #25
    Membre éclairé Avatar de devdeb91
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2013
    Messages
    246
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Janvier 2013
    Messages : 246
    Par défaut
    Comment ça ? Car là je ne vois pas trop il me semble avoir vraiment suivi et vérifié tout.

  6. #26
    Membre émérite

    Homme Profil pro
    Non disponible
    Inscrit en
    Décembre 2012
    Messages
    478
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Non disponible

    Informations forums :
    Inscription : Décembre 2012
    Messages : 478
    Billets dans le blog
    1
    Par défaut
    As tu essayé ? Les erreurs sont les même ? Généralement quand il te met "does not name a type" ou "has not been declared" c'est qu'il ne trouve pas de quel type est ta variable ou ton objet -> erreur de déclaration
    #edit ( Juste déplacer ton de ton personnage.cpp au personnage.h )

  7. #27
    Membre éclairé Avatar de devdeb91
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2013
    Messages
    246
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Janvier 2013
    Messages : 246
    Par défaut
    Oui j'ai essayé et il me dit ces erreurs-la alors que normalement il devrait trouver la classe personnage et savoir que de ce fait c'est une objet je ne comprends pas pourquoi il plante sur un truc aussi bête.

  8. #28
    Membre émérite

    Homme Profil pro
    Non disponible
    Inscrit en
    Décembre 2012
    Messages
    478
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Non disponible

    Informations forums :
    Inscription : Décembre 2012
    Messages : 478
    Billets dans le blog
    1
    Par défaut
    Excuse moi je pense t'induire en erreur, en effet en déclarent la classe elle devrait être reconnu...Je ne vois pas
    #edit Que fait main.h dans ces fichiers ?
    Si tu rajoutes une autre "classe" d'acteur tu vas être embêté avec les includes !
    Regarde du côté du polymorphisme !

  9. #29
    Membre éclairé Avatar de devdeb91
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2013
    Messages
    246
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Janvier 2013
    Messages : 246
    Par défaut
    Ce n'est pas grave je comprends que tu t'y perdes moi aussi à force je m'y perds avec ce programme qui vois pas un truc aussi bête et simple

  10. #30
    Expert éminent
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 644
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 644
    Par défaut
    Une petite précision quant à mes habitudes de codage (comme cela, tout le monde sera au courent )

    Les fonctions qui se contentent d'agir comme des accesseurs (retour d'une valeur ou test + retour de valeur), je les code généralement directement dans la définition de la classe, c'est à dire, directement dans le fichier d'en-tête (*.h / *.hpp)

    La raison est relativement simple : une fonction définie directement dans une classe ou une structure est implicitement inline.

    Il y a donc de fortes chances que la fonction value() dans la classe ci dessous soit, effectivement inlinée par le compilateur.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    class MaClass
    {
        public:
            int value() const{return value_;}
        private:
            int value_;
    };
    Toute fonction qui
    1. manipule un objet (qu'il s'agisse d'un membre de la classe ou d'un objet reçu en paramètre)
    2. appelle (éventuellement de manière conditionnelle) une autre fonction
    3. est virtuelle
    se trouve d'office dans le fichier d'implémentation (*.cpp), entre autres, pour me donner l'occasion d'utiliser la déclaration anticipée chaque fois que faire se peut.

    Il y a, bien sur, quelques exceptions, mais bon, on ne va pas trop s'attarder là dessus

    Ceci dit.

    Comme je l'ai introduit dans mon intervention précédente, il y a beaucoup plus de point commun entre un joueur et un monstre qu'il n'y a, a priori, de différences:
    • Tous deux peuvent attaquer "un adversaire" (quelle que soit la définition que l'on donne à un adversaire)
    • Tous deux disposent d'un certain nombre de points de vie et de mana
    • Tous deux peuvent éventuellement boire des potions
    • Tous deux peuvent disposer d'armes
    • Tous deux peuvent éventuellement se déplacer
    • Tous deux peuvent éventuellement utiliser des sorts
    • Tous deux peuvent disposer d'un inventaire
    • ...
    Les différences sont beaucoup moins nombreuses:
    • Les monstres ne ramassent pas les objets
    • Les monstres ont, typiquement, un inventaire réduit, qui n'évolue pas en cours de partie
    • les monstres sont gérés par "l'intelligence artificielle" alors que le personnage du joueur est géré par ... le joueur
    • un monstre ne gagne ni expérience ni niveau lorsqu'il tue un joueur
    • un joueur commence sa partie au niveau 0, avec des caractéristiques plus ou moins spécifiques à ses spécialités, mais pouvant évoluer, alors qu'un monstre commence à un niveau particulier, avec des caractéristiques propres à son type réel ne pouvant pas évoluer en cours de partie
    • Il y a peut etre encore une ou deux différences, mais très certainement pas des masses
    • On peut sans doute s'attendre à ce que le joueur veuille sauvegarder et recharger son personnage en cours de partie
    Cela semble bel et bien indiquer que, dans de nombreuses circonstances, peu nous chaut que le "personnage" manipulé soit un monstre ou le joueur: on devrait pouvoir le manipuler comme étant... un personnage sans autre spécification.

    Tout semble donc indiquer que la classe Monstre et la classe PersonnageJoueur pourraient parfaitement hériter d'une classe Personnage.

    Si, de plus, on créer une classe ManipulateurDeMonstre et une classe ManipulateurDeJoueur qui héritent toutes les deux d'une classe ManipulateurDePersonnage, il est même possible de faire en sorte que les spécificités propres au joueur soit gérées par un ManipulateurDeJoueur et que celles propres au monstre le soient par un ManipulateurDeMonstre et ce, quoi que l'on décide de mettre dans ces deux classes (la majeure partie des instructions allant du manipulateur au personnage manipulé et non l'inverse )

    Le fait que nos classes PersonnageJoueur et Monstre héritent tous deux d'une même classe de base nous permet de les placer dans une seule et meme collection (de pointeurs sur Personnage) en cas de besoin (entre autres, dés que la notion de "monde" ou de "carte" intervient et qu'il faut, par exemple, être en mesure d'afficher tous les personnages )
    Voyons donc où cela nous mène...

    La classe Personnage, serait sommes toutes relativement similaire à ce que j'ai décrit plus haut.

    Pour éviter tout malentendu, je vais séparer le code en un fichier d'en-tête et un fichier d'implémentation en adaptant le code à ces nouvelles considérations

    Personnage.hpp
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
     
    #ifndef PERSONNAGE_HPP
    #define PERSONNAGE_HPP
    #inculde <inventaire.hpp> // à implémenter ;)
    class Personnage
    {
        public:
            Personnage(int level = 0, int gold=0, int strength=1, int mana=60,
                       int live = 60
                       /*, les autres auxquels je ne pense pas */);
            virtual ~Personnage() ;
            /* !!! C++11 avec compilateur qui l'implémente uniquement
             */
            Personnage(Personnage const &) = delete;
            Personnage & operator = Personnage(Personnage const &) = delete;
            /* on s'attend à pouvoir demander les différentes valeurs */
            int level() const{return level_;}
            int gold() const{return gold_;}
            int strenght () const{return strength_;}
            int mana() const{return mana_;}
            int maxMana() const{return maxMana_;}
            int live() const{return live_;}
            bool alive() const{return live_>0;}
            int maxLive() const{return maxLive_;}
            /* tant qu'on ne sait pas qui attaque qui, on ne peut pas
             * donner d'implémentation ;)
             */
            virtual void attaque(Personnage &) = 0;
            /* tant qu'on ne sait pas qui subit les dégats, on ne peut pas
             * donner d'implémentation ;)
             *
             * degatType : valeur énumérée représentant différents types
             * de dégats auxquels les différents personnages peuvent être
             * plus ou moins sensibles en fonction de tout un tas de facteurs
             * (à implémenter par ailleurs)
             */
           virtual void subitDegats(int degat, degatType type) = 0;
           /* l'expérience que l'on peut gagner en tuant le personnage 
            * dépend du type réel du personnage, et sans doute d'autres
            * facteurs... on ne peut pas donner de comportement par défaut
            */
           vitual int xpToGain() const = 0;
           /* l'or que l'on peut gagner en tuant le personnage
            * dépend du type réel du personnage et sans doute d'autres
            * facteurs... on en peut pas donner de comportement par défaut
            */
     
           /* on peut faire gagner de l'expérience autrement qu'en combat
            */
           virtual void gainXp(int pointToAdd) = 0;
           int goldToGain() const = 0;
           /* Quelque peu en désaccord avec la loi de déméter, mais je ne suis
            * pas réellement inspiré pour trouver autre chose :?
            */
           Inventaire & inventaire() {return inventory_;}
           /* quand on ramasse de l'or ou qu'on vent une piece d'inventaire */
           void addGold(int combien){gold_+= combien; }
           /* quand on achete une pièce d'inventaire, ou qu'on se fait tuer */
           void removeGold(int combien);
        protected:
           /* je préfère avoir des fonctions protégées que des membres protégés ou, pire que tout, des mutateurs...
            * cela permet de n'avoir qu'un code à modifier si on décide de
            * modifier le fonctionnement ;)
            */
            void addXp(int xp);
            /* le comportement lors d'un gain de niveau dépend du type
             * réel du personnage
             */
            virtual void gainLevel() = 0;
            /* une fonction protégée par stat qui peut augmenter
             * en gagnant un niveau ;)
             */
            void addStrenght(int toadd){strenghtMax_+=toadd;}
            void addManaMax(int toadd){manaMax_ += toadd;}
            void addLiveMax(int toadd){liveMax_ += toadd;}
            void increaseLevel(){++level_;}
            void increaseNextLevelAt(){nextLevelAt_ *=1.5;}
            void statToMaximum();
        private:
            int level_;
            int gold_;
            int strenght_;
            int mana_; // nombre de points de mana disponible
            int live_;  // nombre de points de vie disponible
            int maxMana_; // maximum de points de mana
            int maxLive_; // maximum de point de vie
            int experience_; // l'expérience actuelle
            int nextLevelAt_; // expérience requise pour le prochain niveau
            /* tous les autres */
            Inventaire inventory_;
            /* Si pas C++11, ou si pas de support des fonctions "deleted" 
             * on déclare le constructeur par copie et l'opérateur d'affectation
             * dans l'accessibilité privée SANS LES DEFINIR (permettant d'avoir,
             * au mieux une erreur de compilation si on essaye d'utiliser la
             * copie ou l'affectation, au pire, une erreur à l'édition de liens ;) )
             */
             Personnage(Personnage const &);
             Personnage & operator = (Personnage const &);
    };
    #endif //PERSONNAGE_HPP
    Nota: Selon le cas, il faut penser à commenter les lignes 18 et 19 ou les lignes 48 et 49 de Personnage.hpp (ou les entourer de directive préprocesseur ad-hoc, si on dispose d'un moyen de vérifier la présence de cette fonctionnalité lors de la configuration du projet )
    Personnage.cpp
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
     
    #include <Personnage.hpp>
    #include <NoGoldEnough.hpp> // à implémenter
    Personnage::Personnage(int level, int gold, int strength, int mana,
                           int live
                           /*, les autres auxquels je ne pense pas */):level_(level);
                           gold_(gold),strength_(strength), mana_(mana),
                           maxMana_(mana), live_(live), maxLive_(live)
                           /* tous les autres */
    {}
    Personnage::~Personnage(){}
    void Personnage::removeGold(int combien)
    {
        if(gold_-combien <0)
            throw NoGoldEnough(); // exception à implémenter ;)
        gold_ -= combien;
    }
     void Personnage::addXp(int xp)
    {
        experience_+= xp;
        if(experience_ >= nextLevelAt_)
        {
            gainLevel();
        }
    }
     
    void Personnage::statToMaximum()
    {
        mana_=manaMax_;
        live_=liveMax_;
    }
    PersonnageJoueur.hpp
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #ifndef PERSONNAGEJOUEUR_HPP
    #define PERSONNAGEJOUEUR_HPP
    class PersonnageJoueur : public Personnage
    {
        public:
            PersonnageJoueur();
            virtual ~PersonnageJoueur();  
            virtual void attaque(Personnage & ennemy);
            virtual void subitDegats(int degat, degatType type);
            vitual int xpToGain() const;
            virtual void gainXp(int pointToAdd);
        protected:
            virtual void gainLevel();
    }
    #endif //PERSONNAGEJOUEUR_HPP
    PersonnageJoueur.cpp
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    #include <PersonnageJoueur.hpp>
     
    /* Le constructeur va utiliser les valeurs par défaut introduites
     * dans le constructeur de Personnage.
     * Mais, si l'on envisage de prévoir différents types de personnages
     * joueurs (Archer, Guerrier, Magicien, Voleur, ...) on pourrait malgré
     * tout prévoir des arguments (car les stats de départ d'un Archer sont
     * sans doute différentes de celles d'un guerrier ;))
     */
    PersonnageJoueur::PersonnageJoueur():Joueur()
    {}
    PersonnageJoueur::~PersonnageJoueur()
    {}
     
    void PersonnageJoueur::attaque(Personnage & ennemy)
    {
        degatType  type =/*choix du type de dégats... dépendant des circonstances ;) */;
        int degat = /* choix des dégats dépendant des circonstances */;
        ennemy.subitDegat(degat, type);
        if(!ennemy.alive())
        {
            gainXp(ennemy.xpToGain());
            addGold(ennemy.goldToGain());
        }
     
    }
    void PersonnageJoueur::subitDegats(int degat, degatType type)
    {
        /* calcul des dégats réellement subits en fonction des circonstances
         */
    }
    void PersonnageJoueur::gainXp(int pointToAdd)
    {
         addXp(toadd);
    }
    /* typiquement, si tu prévois différents types de joueur, cette
     * fonction sera définie pour chaque type concret de joueur (avec
     * des des évolutions qui leurs sont propres ;))
    void PersonnageJoueur::gainLevel()
    {
        increaseLevel();
        increaseNextLevelAt();
        /* pour l'exemple, j'ajoute 50 % de vie et de mana ;) */
        addManaMax(manaMax()*0.5);
        addLiveMax(liveMax() *0.5);
        statToMaximum();
     
    }
    /* Tuer un joueur ne rapporte aucune expérience */
    int PersonnageJoueur::xpToGain() const
    {
        return 0;
    }
    /* par contre, quand un joueur meurt, il perd 10 % de son or
     * (s'il est tué par un autre joueur, celui ci peut récupérer cet or :D)
     */
    int PersonnageJoueur::goldToGain()
    {
        int temp = gold() /10;
        const_cast<PersonnageJoueur &>(*this).removeGold(temp);
        return temp;
    }
    Le monstre est un personnage, mais on a dit qu'il ne gagnait ni or ni expérience lorsqu'il tuais un joueur.

    Mais on peut estimer que nous aurons affaire à différents types de monstres, de différents niveaux et que l'expérience ou que la quantité d'or que l'on peut gagner en tuant un monstre dépendra du type réel du monstre et de son niveau (gagner 10 pièces d'or en tuant un orc de niveau 27 armé jusqu'aux dents et 5 pièces d'or en tuant une limace baveuse de niveau 1, ou ne pas gagner plus d'expérience à tuer l'orc qu'à tuer la limace baveuse ne serait sans doute pas motivant pour le joueur )

    On peut donc estimer que nous aurons "un certain nombre" de classes dérivées de Monstre qui correspondront à ... autant de type réels de monstres que ce dont nous aurons besoin.

    Dans la classe Monstre, il est dores et déjà possible de redéfinir certains comportements dont on sait qu'ils n'évolueront plus, quel que soit le type réel du monstre, à savoir gainXp et gainLevel, car ce sont des fonctions qui n'ont strictement aucun effet sur les monstres (et que l'on ne devrait d'ailleurs jamais essayer d'invoquer ).

    L'implémentation des autres fonctions virtuelles pures de Personnage devra, par contre, se faire au niveau des classes dérivées de Monstre, lorsque l'on saura exactement de quel monstre il s'agit

    La classe Monstre se présenterait donc sous une forme proche de
    Monstre.hpp
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    #ifndef MONSTRE_HPP
    #define MONSTRE_HPP
    class Monstre : public Personnage
    {
        public:
            /* hé oui, toutes ces données seront fournies par le type
             * réel de monstre que l'on voudra créer ;)
             */
            Monstre (int level, int gold, int strength, int mana,
                       int live
                       /*, les autres auxquels je ne pense pas */);
            virtual ~Monstre () ;
            virtual void gainXp(int pointToAdd);
        protected: 
            virtual void gainLevel();
     
    };
    #endif // MONSTRE_HPP
    Monstre.cpp
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
     
    Monstre::Monstre (int level, int gold, int strength, int mana,
                       int live
                       /*, les autres auxquels je ne pense pas */):
                    Personnage(level, gold, strength, mana, live /*les autres
                    auxquels je ne pense pas */)
    {}
    Monstre::~Monstre () 
    {}
    /* par défaut, ca ne fait rien, évitant ainsi à l'utilisateur de faire une 
     * bêtise :D
     */
    void Monstre::gainXp(int pointToAdd)
    {}
    void Monstre::gainLevel(){}
    Après il y a toutes les classes de monstres de type particulier, éventuellement une factory et la gestion de tout ce beau monde à mettre en oeuvre... mais c'est une autre histoire, que je vous conterai peut etre un jour
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  11. #31
    Membre éclairé Avatar de devdeb91
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2013
    Messages
    246
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Janvier 2013
    Messages : 246
    Par défaut
    Bon je vais analyser tout ça car beaucoup de choses apparaissent et me paraissent inconnu. J'ai aussi pensé à definir le monstre comme étant un personnage mais je voulais bien les différencier mais bon vu que je commence à ne pas avoir le choix à cause de ces erreurs je vais ne pas les différencier. Je fait des retours très vite et merci pour ce très long post je serais ravi de t'entendre conter d'autres histoires mais cela un autre jour car il faut que je digère déjà celle-ci

+ Répondre à la discussion
Cette discussion est résolue.
Page 2 sur 2 PremièrePremière 12

Discussions similaires

  1. Structure ou classe ?
    Par progfou dans le forum C++
    Réponses: 5
    Dernier message: 01/10/2007, 14h27
  2. Schéma structure des classes
    Par delma dans le forum EDI et Outils pour Java
    Réponses: 8
    Dernier message: 29/11/2006, 16h52
  3. [log4j] structurer par classes
    Par frouge dans le forum Logging
    Réponses: 4
    Dernier message: 25/09/2006, 11h24
  4. Structure de classe dynamique
    Par amel666 dans le forum Langage
    Réponses: 2
    Dernier message: 24/01/2006, 09h13
  5. structure de class?
    Par kiko69 dans le forum C++
    Réponses: 4
    Dernier message: 13/03/2005, 14h30

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo