structure et class

Version imprimable

08/03/2013, 14h30
devdeb91

structure et class

bonjour

alors voila j'ai une class personnage mais pour ce personnage on doit retenir plein d'info sur lui par exemple xp, argent, force, etc... donc je me demande ne vaut t'il pas mieux changer la class en structure. seul probleme c'est que j'ai besoin des constructeur que on ne trouve pas dans les structure du coup j'aurai besoin de conseil.

que feriez vous ?
quel serais la meilleur solution ?
08/03/2013, 16h00
koala01
Salut,

De manière générale, une classe et une structure sont strictement identiques en C++, à une exception près: la visibilité par défaut de ses membres, qui est privée pour les classes et publique pour les structures.

Ceci dit:

Le meilleur moyen de définir des valeurs particulières pour une classe passe par son constructeur, en fournissant les arguments "qui vont bien" et, le cas échéant, en fournissant des valeurs par défaut.

Il n'y a, a priori, aucun lien direct entre les différentes valeurs que tu peux vouloir utiliser pour ton personnage (force, xp, argent, mana, etc), il n'y a donc aucune raison de vouloir les regrouper "ailleurs" que dans ton personnage ;)

S'il y a des raisons pour placer des accesseurs sur ces valeurs (après tout, on s'attend de la part du personnage à ce qu'il puisse répondre à des questions comme "quelle est ta force / ton niveau / ton expérience / la somme d'argent dont tu disposes"), il n'y a pas lieu de fournir des mutateurs classiques:

La plupart de ces valeurs seront modifiées dans certaines situations:
- L'expérience augmente quand le personnage est avisé qu'il a tué son adversaire, dans une proportion dépendant de l'adversaire qu'il a tué (et e son propre niveau, par exemple)
- Son mana diminue lorsqu'il décide de lancer un sort, en fonction de la quantité de mana pour ce faire et augmente quand le personnage décide de boire une potion, en fonction de la quantité de mana que la dite potion lui octroie, voir, d'une valeur donnée toutes les X secondes.
- La somme d'argent dont il dispose augmente en fonction de ce qu'il ramasse
- ...
Toutes ces situations représentent autant de services que tu es sans doute en droit d'attendre de la part de ton personnage, et c'est de ce point de vue qu'il faut que tu en arrive à les manipuler ;)
08/03/2013, 16h15
devdeb91

Je suis tout à fait d'accord avec ça mais au niveau des stats après ça fera sans doute beaucoup d'attributs privés non car si on observe bien à part les stats vie magie xp argent il faut retenir la force vitesse agilité résistance physique résistance magique force magique etc... ça fait beaucoup pour une classe non ?

Visiblement, tu n'as pas compris ce que je voulais expliquer.

Ton personnage manipule en interne toutes ces données, mais il n'y a pas forcément lieu de créer une classe pour représenter son niveau, une autre pour représenter sa force et une troisième pour représenter la somme d'argent dont il dispose : de "simples" valeurs numériques sont amplement suffisantes ;)

L'idée est d'avoir une classe "personnage" qui pourrait ressembler à quelque chose comme
Code:

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 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 */):level_(level); gold_(gold),strength_(strength), mana_(mana), maxMana_(mana), live_(live), maxLive_(live) /* tous les autres */ {} /* 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_;} /* ce que j'ai oublié */ 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_; };
Quand tu veux afficher les stats, tu n'as donc qu'à demander les différentes valeurs que tu veux afficher ;)

Ensuite, tu attends une série de services de la part de ton personnage, qui vont régulièrement manipuler l'une ou l'autre de ces données (ou parfois plusieurs!).

Par exemple, on peut se dire que quand le personnage tue un ennemi, il se passe plusieurs choses simultanées:
il gagne un certain nombre de points d'expérience
il récupère une certaine somme d'argent sur l'ennemi
il peut récupérer certains objets d'inventaire
... plein de choses qui dépendent de ton gameplay
Certaines de ces choses peuvent d'ailleurs provoquer d'autres changements. Le fait de gagner de l'expérience peut, par exemple, te faire passer de niveau!

Mais pour tuer un ennemi, il faut l'avoir attaqué, et c'est surtout cela qui va t'intéresser.

Tu complèteras donc sans doute ton interface Personnage sous une forme proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class Personnage { /* tout ce dont j'ai parlé plus haut */ public: void attack(Personnage & ennemy) { ennemy.subitAttaque(/* ... */); if(! ennemy.alive()) { gainXp(ennemy.xpToGain()); gainGold(ennemy.xpToGain()); pillerInventaire(ennemy.inventaire()); } } };
ouppss... voila trois fonctions dont je n'ai pas parlé.

En fait, gainXp, gainGold et pillerInventaire sont des comportements que le personnage peut avoir, mais dont on ne s'attend pas forcément à pouvoir appeler depuis "l'extérieur" (à par gainGold ou pillerInventaire ;))

Il est donc bon de faire en sorte que seul les fonctions membres de Personnage puissent y avoir accès en les rendant privées, sous une forme proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 class Personnage { /* tout ce dont j'ai parlé plus haut */ private: void gainExperience(int toGain) { experience_ += toGain; if(experience_>= nextLevelAt_) { gainedLevel(); } } void gainGold(int toGain) { gold_ += toGain; } void pillerInventaire(Inventaire & toTake) { /* passer tous les objets qui peuvent l'être de * toTake à inventory_ */ } };
Et, décidément, je viens encore de rajouter une fonction inconnue: gainedLevel, qui prend "simplement" en charge les modifications à apporter lorsque l'on gagne un niveau, et qui pourrait ressembler à quelque chose comme
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class Personnage { /* tout ce dont j'ai parlé plus haut */ private: void gainedLevel() { level_++; /* pour le prochain niveau, il faut moitié plus d'expérience que * pour le niveau actuel */ nextLevelAt_ = nexLevelAt_ * 1.5; /* en gagnant un niveau, on augmnte d'un tiers la mana maximale * et la vie maximale */ manaMax_ = manaMax_ *4 / 3; liveMax_ = liveMax_ * 4 / 3; /* et on se retrouve avec la mana et la vie au maximum */ live_= liveMax_; mana_ = manaMax_; } };
Bien sur, ces comportements sont tels que je les imagine moi, avec des valeurs arbitraires choisies par moi, et peuvent parfaitement être adaptés selon ton propre gameplay ;)

Il n'est d'ailleurs pas exclu que tu veuille pouvoir faire gagner de l'or, de l'expérience ou du matériel autrement qu'en tuant un ennemi (en terminant une quête, en vendant ou en achetant du matériel, et autres possibilités).

Certaines des fonctions dont je viens de parler ici (comme gainExperience ou gainGold) peuvent donc se retrouver en accessibilité publique et d'autres (gainedLevel), tout en restant privées, peuvent être virtuelles pour profiter du polymorphisme, afin que les stats soient modifiées de manière différentes si le personnage est un guerrier, un archer ou un magicien ;)

Mais ca, ca dépend de ton gameplay, du jeu que tu veux créer et de plein d'aspects que j'ignore pour l'instant ;)

Ce qui importe, c'est que tu te rendes compte de plusieurs choses:

Tu peux accéder en lecture à tes différentes statistiques parce que cela correspond à certains services que tu es en droit d'attendre de la part de ton personnage
Toute modification des statistiques passe d'office par l'appel d'un comportement spécifique de ton personnage
Certains comportements de ton personnages peuvent être publics parce que ce sont des services que l'on est en droit d'attendre de sa part, d'autres ne sont que des "comportements internes" dont on n'a pas à s'occuper ailleurs qu'au niveau des différentes fonctions membres de personnage.
Certains services que tu es en droit d'attendre de la part de ton personnage sont susceptibles, dans certaines circonstances, d'appeler d'autres comportements ou d'autres services, voire de modifier les statistiques de ton personnage.
Tu dois donc penser à ton personnage en termes de services que tu es en droit d'attendre de sa part, et non en termes de données qu'il manipule.

Les données qu'il manipulent sont, typiquement des "détails d'implémentation" qui permettent au personnage de rendre les services que l'on est en droit d'attendre de sa part ;)

Ainsi, j'aurais très bien pu regrouper tous les int dans un seul tableau, cela n'aurait rien changé pour l'utilisateur de la classe Personnage (même ca aurait changé le code pour accéder aux différentes stats au niveau des fonctions membres de Personnage ) ;)

08/03/2013, 21h30
devdeb91

Si si je suis très bien et je suis tout à fait d'accord tout ça été prévu c'est juste le fait qu'il y ait autant attribut car j'ai eu l'habitude de faire des classes avec 4-5 attributs privés max et là il y en a une dizaine du coup je ne savais pas si c'était vraiment bien d'en avoir autant en général quand j'en ai autant j'utilise des structures c'est cela qui me perturbait c'est tout après sur le reste ça je suis tout à fait d'accord avec toi.

par ailleurs pour les monstres j'ai fait comme ceci

Code:

std::map<int, SMonstre> monstre;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
struct SMonstre {
        SMonstre(std::string nom, int hp, int mp, std::string type, int exp, int gold):
            nom(nom), hp(hp), mp(mp), type(type), exp(exp), gold(gold){}
 
    std::string nom;
    int hp;
    int mp;
    std::string type;
    int exp;
    int gold;
 
};

Code:

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
void chargemonstre(SMap & Map, string filename, int index)
{
    cout << "chargement monstre" << endl;
 
    ifstream ifs(filename);
    int ligne = 0;
    while(!ifs.eof())
    {
        char c = ifs.get();
        if(c == '\n')
        {
            ligne++;
        }
    }
    //cout << "ligne " << ligne << endl;
 
    /*std::tr1::mt19937 gen(time(0));
    std::tr1::uniform_int <int> a(1,ligne);
    int lignechoisi = a(gen);*/
    //srand(time(0));
    int lignechoisi  = 0;
    lignechoisi = (rand() % ligne);
    cout << "ligne choisi " << lignechoisi << endl;
   /* ifs.clear();
    ifs.seekg(0, ios::beg);
    int pos = ifs.tellg();
    cout << "position " << pos << endl;*/
    ifs.close();
    ifs.open(filename);
//    ifstream ifs(filename);
    //lignechoisi--;
    while(lignechoisi > 0)
    {
        //cout << "entrer 2eme boucle" << endl;
        char c = ifs.get();
        //cout << c << endl;
        if(c == '\n')
        {
            //cout << c << " trouver" << endl;
            lignechoisi--;
            //cout << "ligne " << lignechoisi << endl;
        }
        /*string nom;
        getline(ifs, nom);
        lignechoisi--;
        cout << nom << endl;*/
    }
 
    string nom;
    int hp;
    int mp;
    string type;
    int exp;
    int gold;
    //cout << "remplissage" <<  endl;
    ifs>>nom>>hp>>mp>>type>>exp>>gold;
 
    //cout << nom << " " << hp << " " << mp << " " <<
    //        type << " " << exp << " " << gold << endl;
    //cout << "fin remplissage" << endl;
    //Map.monstre.insert(std::make_pair(Position(joueur.x(), joueur.y()), SMonstre(nom, hp, mp, type, exp, gold)));
    Map.monstre.insert(std::make_pair(int(index), SMonstre(nom, hp, mp, type, exp, gold)));
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
else if(Map.tileAt(joueur.x(), joueur.y()) == 'M')
           {
               Map.monstre.clear();
               srand(time(NULL));
               int nbmonstre = 0;
               while(nbmonstre == 0)
               {
                   nbmonstre = rand() % 5;
               }
               string filename = Map.title + "_monstre" + ".txt";
               cout << "nombre monstre " << nbmonstre << " " << "nom fichier " << filename << endl;
               for(int i = 0; i < nbmonstre; i++)
               {
                   chargemonstre(Map, filename, i);
               }
 
               for(int i = 0; i < nbmonstre; i++)
               {
                   cout << "monstre " << i <<endl;
                  auto it = Map.monstre.find(i);
               cout << it->second.nom << " " << it->second.hp <<" "<< it->second.mp << " " <<
                       it->second.type << " " << it->second.exp << " " << it->second.gold << endl;
               }
           }

est ce bien ? car maintenant que je vois mieux je me demande si c'est pas mieux de passer par une class monstre

Citation:

Envoyé par devdeb91

si si je suis trés bien et je suis tout a fait d'accord tout sa été prevue c'est juste le fait qu'il est autant attribut car j'ai eu l'habitude de faire des class avec 4-5 attribut privé max et la y en a une dizaine du coup je ne savais pas si c'était vraiment bien d'en avoir autant en général quand j'en est autant j'utilise des structure c'est cela qui me perturber c'est tout aprrés sur le reste sa je suis tout a fait d'accord avec toi.

Oh, il y aurait effectivement moyen de passer par des interfaces et par l'héritage multiple pour éviter d'avoir trop d'attributs dans ta classe Personnage (ce pourrait d'ailleurs être conseillé :D), mais cela reviendrait au final à peu près au même :D.

Ceci dit, il faut te dire que les différents attributs de ta classe ne sont là que pour permettre à ta classe de fournir les services que l'on en attend.

Dans le cadre d'un personnage de jeu, on s'attend à ce qu'il fournisse un grand nombre de services, il n'est donc pas étonnant outre mesure qu'il soit composé... d'un nombre important d'attributs ;)
Citation:
Envoyé par devdeb91
par ailleurs pour les monstres j'ai fait comme ceci

Code:

std::map<int, SMonstre> monstre;
Code:

1 2 3 4 5 6 7 8 9 10 11 12 struct SMonstre { SMonstre(std::string nom, int hp, int mp, std::string type, int exp, int gold): nom(nom), hp(hp), mp(mp), type(type), exp(exp), gold(gold){} std::string nom; int hp; int mp; std::string type; int exp; int gold; };
Avoir une chaine de caractères pour le type, c'est moyen moyen...

Et ce ne serait qu'à peine mieux si tu décidais de remplacer cette chaine par une valeur énumérée.

Le fait est que, si tu as plusieurs types de monstres possibles, tu devrais envisager de créer une classe de base Monstre, et une classe dérivée de Monstre par type de monstre que tu envisage de créer.

Pour manipuler un monstre d'un type donné comme étant de son type particulier et non du type Monstre, il faudrait alors passer par le double dispatch.

Evidemment, cela signifie que tu devrais utiliser une map de type <int, Monstre * > (ou mieux, basée sur un pointeur intelligent), et qu'il faudrait sans doute avoir recours au patron de conception Fabrique, histoire que le système de gestion des monstres n'aie pas à connaitre l'ensemble des différents types de monstres existants ;)

Citation:

est ce bien ?

C'est largement perfectible ;)

Citation:

car maintenant que je vois mieux je me demande si c'est pas mieux de passer par une class monstre

En fait, à bien y regarder, il y a de nombreux points communs entre les monstres et le personnage (d'ailleurs, dans quelle mesure ne pourrait on pas envisager le fait qu'un monstre n'est jamais qu'un personnage particulier :question:)

On pourrait donc assez facilement en arriver à la conclusion qu'il est possible de regrouper dans la classe personnage ce qui est commun aux monstres et à ce que l'on appelle pour l'instant personnage, et d'avoir une classe "joueur" et une classe "monstre" qui prendraient en charge ce qui est spécifique à ces deux types distincts.

Quand je te disais, lorsque tu a émis l'idée de créer un jeu, qu'il fallait vraiment commencer par réfléchir à tes besoins et au fait que ceux ci allaient évoluer afin de ne pas te retrouver bloqué sur une évolution :D

alors voila j'ai créer mes 2 class mais un probleme est detecter

Code:

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
#ifndef MONSTRE_H_INCLUDED
#define MONSTRE_H_INCLUDED
#include <string>
#include "main.h"
#include "personnage.h"
 
 
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 // MONSTRE_H_INCLUDED

il me dis

Code:

1
2
3
4
C:\Users\kevin\Desktop\jeu2\monstre.h|27|error: 'personnage' has not been declared|
C:\Users\kevin\Desktop\jeu2\monstre.h||In member function 'void monstre::attaquer(int&)':|
C:\Users\kevin\Desktop\jeu2\monstre.h|29|error: request for member 'recevoir_degats' in 'cible', which is of non-class type 'int'|
||=== Build finished: 2 errors, 0 warnings (0 minutes, 1 seconds) ===|

alors que je lui dis bien d'aller prendre personnage.h donc auriez vous une idée de se qu'il veut

10/03/2013, 20h50
Neckara

Si tu as suivi les conseils de Koala01, je suppose que tu as mis une majuscule à Personnage, majuscule que tu n'aurais pas reporté dans monstre.h ?

Sinon, prend bien l'habitude de mettre des majuscules à tes classes pour éviter de les confondre avec des variables.

Si ce n'est pas le cas, pourrais-tu nous montrer ton personnage.h?

Non pas mis bien que je le fait d'habitude.

voici le personnage.h

Code:

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
#ifndef PERSONNAGE_H_INCLUDED
#define PERSONNAGE_H_INCLUDED
#include "main.h"
#include "monstre.h"
//#include "arme.h"
 
class personnage
{
    private:
 
        int m_hp;
        int m_pm;
        int m_xp;
        int m_or;
        //arme m_arme;
 
    public:
 
        personnage(): m_hp(1000), m_pm(20), m_xp(0), m_or(500){}
        ~personnage()
        {
 
        }
        void recevoir_degats(int nombre_degats)
        {
            m_hp -= nombre_degats;
            if(m_hp < 0)
                m_hp = 0;
        }
        //void soin(int nombre_soin);
        void attaquer(monstre &cible)
        {
            cible.recevoir_degats(15);
        }
        //void magie(personnage &cible);
        //void objet(std::string nom);
        bool est_vivant()
        {
 
            if(m_hp > 0)
                return true;
            else
                return false;
        }
        void recevoir_gain(int xp, int argent)
        {
            m_xp = m_xp + xp;
            m_or = m_or + argent;
        }
 
};
 
#endif // PERSONNAGE_H_INCLUDED

Tu va être obligé d'utiliser des déclarations anticipée pour éviter les dépandances cycliques :
Code:

1 2 3 4 5 6 7 8 9 10 11 class A; class B { A * a; } class A { B * b; }
Soit dans un .h :
Code:

1 2 3 4 class Personnage; class Monstre{}
Code:

1 2 3 class Monstre; class Personnage{}

10/03/2013, 21h16
devdeb91

ok bah j'essaye ça merci. par contre comment faire car une des deux classes utilise personnage et l'autre monstre donc l'une ne verra pas la classe de l'autre vue qu'elle sera après et donc ne pourra pas déclarer l'objet
10/03/2013, 21h25
Neckara

Pourtant avec mes classes A et B je n'ai eu aucun problème.
Pour mon second exemple je n'ai pas mis un Monstre * dans Personnage et un Personnage * dans Monstre mais c'est tout comme.

Il me dit

Code:

1
2
3
4
C:\Users\kevin\Desktop\jeu2\monstre.h||In member function 'void monstre::attaquer(personnage&)':|
C:\Users\kevin\Desktop\jeu2\monstre.h|30|error: invalid use of incomplete type 'class personnage'|
C:\Users\kevin\Desktop\jeu2\monstre.h|7|error: forward declaration of 'class personnage'|
||=== Build finished: 2 errors, 0 warnings (0 minutes, 1 seconds) ===|

je pense avoir fait comme tu as dis

Code:

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
#ifndef MONSTRE_H_INCLUDED
#define MONSTRE_H_INCLUDED
#include <string>
#include "main.h"
//#include "personnage.h"
 
class personnage;
 
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 // MONSTRE_H_INCLUDED

j'ai aussi tester sa

Code:

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
#ifndef PERSONNAGE_H_INCLUDED
#define PERSONNAGE_H_INCLUDED
#include "main.h"
#include <string>
//#include "monstre.h"
//#include "arme.h"
 
class monstre;
 
class personnage
{
    private:
 
        int m_hp;
        int m_pm;
        int m_xp;
        int m_or;
        //arme m_arme;
 
    public:
 
        personnage(): m_hp(1000), m_pm(20), m_xp(0), m_or(500){}
        ~personnage()
        {
 
        }
        void recevoir_degats(int nombre_degats)
        {
            m_hp -= nombre_degats;
            if(m_hp < 0)
                m_hp = 0;
        }
        //void soin(int nombre_soin);
        void attaquer(monstre &cible)
        {
            cible.recevoir_degats(15);
        }
        //void magie(personnage &cible);
        //void objet(std::string nom);
        bool est_vivant()
        {
 
            if(m_hp > 0)
                return true;
            else
                return false;
        }
        void recevoir_gain(int xp, int argent)
        {
            m_xp = m_xp + xp;
            m_or = m_or + 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_INCLUDE

même erreur dans les deux cas

10/03/2013, 21h33
Neckara

Je ne t'ai donné la solution que pour les header.

Ensuite il faut inclure les header personnage.h et monste.h dans les deux .cpp

EDIT : pense aussi à mettre le corps des méthodes dans les .cpp
10/03/2013, 21h59
devdeb91

bah j'ai inclus dans les cpp mais ça me met l'erreur quoi qu'il arrive si tu veux je joins tout le code entier mais je suis pas sur que ça serve
10/03/2013, 22h34
PilloBuenaGente

Je pense que Nekara te parles de ce qui est expliqué ici http://cpp.developpez.com/faq/cpp/?p...erence_croisee
10/03/2013, 22h38
devdeb91

Merci du lien celui ci je ne l'avais pas trouvé mais comment faire dans le cadre de 2 .h sans cpp car j'ai pris l'habitude de faire comme koala c'est à dire de mettre tout dans les .h et pas faire de .cpp du coup sa pose problème
10/03/2013, 22h42
Neckara

Je doute fortement que Koala01 ait l'habitude de tout mettre dans le .h, c'est juste que c'est plus facile/pratique quand on veut montrer des petits exemples sur le forum ou expliquer quelque chose.

@PilloBuenaGente : Oui c'est cela merci.
Je dois avouer que c'est un peu de ma faute de ne pas tout avoir expliqué dès le début :aie:.
10/03/2013, 22h45
devdeb91

Je n'ai pas dis qu'il avait cette habitude j'ai dit que j'ai pris l'habitude de faire comme lui (en gros comme ce qu'il ma montré) désolé si je me suis mal exprimé.

alors voila suite au lien donné http://cpp.developpez.com/faq/cpp/?p...erence_croisee j'ai suivi le meme exemple

Code:

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:

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:

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:

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:

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

10/03/2013, 23h22
PilloBuenaGente

#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 ^^)
10/03/2013, 23h40
devdeb91

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
10/03/2013, 23h45
PilloBuenaGente

C'est qu'ici tu utilise ton monstre dans ton header
10/03/2013, 23h47
devdeb91

Comment ça ? Car là je ne vois pas trop il me semble avoir vraiment suivi et vérifié tout.
10/03/2013, 23h51
PilloBuenaGente

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

Code:

#include monstre.h

de ton personnage.cpp au personnage.h )
10/03/2013, 23h59
devdeb91

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.
11/03/2013, 00h03
PilloBuenaGente

Excuse moi je pense t'induire en erreur, en effet en déclarent la classe elle devrait être reconnu...Je ne vois pas :oops:
#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 !
11/03/2013, 00h04
devdeb91

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

Une petite précision quant à mes habitudes de codage (comme cela, tout le monde sera au courent :D)

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:

1 2 3 4 5 6 7 class MaClass { public: int value() const{return value_;} private: int value_; };
Toute fonction qui
manipule un objet (qu'il s'agisse d'un membre de la classe ou d'un objet reçu en paramètre)
appelle (éventuellement de manière conditionnelle) une autre fonction
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:

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:

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:

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:

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:

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:

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 ;)

11/03/2013, 10h09
devdeb91

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 :lol: 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 :)