Probleme avec les heritages.

Bonjour,

Je suis un debutant en C++. J'essaie de apprendre le C++ comme passe-temps pendant mes vacances. Je travaille avec les classe mere & class fille. Puis, je suis tombé dans une erreur que je ne comprends pas. Ce n'est pas marqué dans mon compilateur mes quand je met des valeurs a mes attributs de l'objet "niggajutsu"(nom & classe), ça retourne les valeurs par default.

Explication visuel :
http://nsa34.casimages.com/img/2013/...2926331614.jpg

Vous voyez? Lorsque j'ecris comme nom : "Pierre" & ma classe : "h". Sa retourne que mon nom est Ken (Nom par defaut) & ma classe est "s"(Classe par defaut).
Quelqu'un peux m'aider Svp?

Arme.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
#ifndef DEF_ARME
#define DEF_ARME
#include <iostream>
#include <string>
#include "Assassin.h"
class Assassin;
 
/* Creer des armes */
class Arme
{
	/* Les attributs d'une arme */
private:
	std::string m_nomArme;
	double m_puissanceArme;
	double m_rapiditeArme;
	double m_energieArme;
	double m_resistanceArme;
	int m_xpArme;
	int m_levelArme;
 
/* Les actions que l'arme peut faire */
public:
	Arme(char& job);
	Arme::Arme();
	void choisirArme(char& job);
	void information() const;
	void choisirArme(Assassin& proprietaire);
	std::string getNom() const;
	double getPuissance() const;
	double getRapidite() const;
	double getResistance() const;
	double getEnergie() const;
	void gagnerXp(int& xpRecu);
};
 
#endif

Assassin.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
#ifndef DEF_ASSASSIN
#define DEF_ASSASSIN
#include <iostream>
#include <string>
#include "Monstre.h"
#include "Arme.h"
class Monstre;
class Arme;
 
/* Creer les assassins */
class Assassin
{
	/* Les attributs d'un assassin */
protected:
	std::string m_nom;
	char m_class;
	double m_hp;
	double m_sp;
	int m_xp;
	int m_level;
	double m_puissance;
	double m_rapidite;
	double m_energie;
	double m_resistance;
	bool m_estVivant;
	Arme *m_arme;
 
	/* Les actions que l'assassin peut faire ou recevoir */
public:
	void perdreHp(double nbDegat); 
	void perdreSp(double perte);
	void gagnerXp(int const& levelEnnemi, bool const& ennemiVivant);
	void gagnerHp(bool const& ennemiVivant);
	void gagnerSp(bool const& ennemiVivant);
	void attaquer(Monstre &cible);
	void superAttaque(Monstre &cible);
	bool getVivant() const;
	void information() const;
	Assassin(std::string& pseudo,char& job);
	Assassin();
	~Assassin();
	void gagnerCapacite(bool const& ennemiVivant);
	char getClass() const;
	double getHp() const;
	void Etat() const;
	Assassin& operator=(Assassin const& a);
};
 
#endif

Guerrier.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef DEF_GUERRIER
#define DEF_GUERRIER
#include <iostream>
#include <string>
#include "Assassin.h"
 
class Guerrier : public Assassin
{
public:
	void rajouterVie();
	Guerrier(std::string& pseudo,char& job);
};
 
#endif

Monstre.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
#ifndef DEF_MONSTRE
#define DEF_MONSTRE
#include <iostream>
#include <string>
#include "Assassin.h"
class Assassin;
 
/* Creation des Monstres */
class Monstre
{
private:
	/* Attribut des Monstres */
	double m_hp;
	double m_sp;
	int m_level;
	double m_puissance;
	double m_rapidite;
	double m_energie;
	double m_resistance;
	bool m_estVivant;
 
	/* Action que les monstres peuvent recevoir & faire */
public:
	void perdreHp(double const nbDegat);
	void perdreSp(double perte);
	void attaquer(Assassin &cible);
	void superAttaque(Assassin &cible);
	int getLevel() const;
	bool getVivant() const;
	void information() const;
	Monstre(int const& niveauMonstre);
	Monstre();
	double getHp() const;
	void Etat() const;
};
 
#endif

Ninja.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef DEF_NINJA
#define DEF_NINJA
#include <iostream>
#include <string>
#include "Assassin.h"
 
class Ninja : public Assassin
{
public:
	void comboAttack();
	Ninja(std::string& pseudo,char& job);
};
 
#endif

Slugger.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef DEF_SLUGGER
#define DEF_SLUGGER
#include <iostream>
#include <string>
#include "Assassin.h"
 
class Slugger : public Assassin
{
public:
	void oneShotFinishAttack();
	Slugger(std::string& pseudo,char& job);
};
 
#endif

SuperHeros.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef DEF_SUPERHEROS
#define DEF_SUPERHEROS
#include <iostream>
#include <string>
#include "Assassin.h"
 
class SuperHeros : public Assassin
{
public:
	void enleverVieEnemie();
	SuperHeros(std::string& pseudo,char& job);
};
 
#endif

Arme.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
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
101
102
103
104
105
#include "Arme.h"
#include <iostream>
#include <string>
using namespace std;
 
/* Creer une arme */
Arme::Arme(char& job)
{
	m_levelArme = 1;
	choisirArme(job);
}
 
Arme::Arme()
{
	m_levelArme = 1;
	char job('s');
	choisirArme(job);
}
 
 
/* Retourner le nom de l'arme */
string Arme::getNom() const
{
	return m_nomArme;
}
 
/* Choisir une arme en fonction de la class */
void Arme::choisirArme(char& job)
{
	m_levelArme = 1;
	m_resistanceArme = 5;
	m_rapiditeArme = 5;
	m_energieArme = 5;
	m_puissanceArme = 5;
	m_xpArme = 0;
	switch(job)
	{
	case 'g':
		m_resistanceArme = 10;
		m_nomArme = "Katana en bois";
		break;
	case 'n':
		m_rapiditeArme = 10;
		m_nomArme = "Kunai basic";
		break;
	case 'h':
		m_energieArme = 10;
		m_nomArme = "Baton magique basic";
		break;
	default:
		m_puissanceArme = 10;
		m_nomArme = "knuckle basic";
		break;
	}
}
 
/* Montrer les informations de l'arme */
void Arme::information() const
{
	cout << "Nom de l'arme : " << m_nomArme << endl;
	cout << "Niveau de l'arme : " << m_levelArme << endl;
	cout << "Puissance de l'arme : " << m_puissanceArme << endl;
	cout << "Rapidite de l'arme : " << m_rapiditeArme << endl;
	cout << "Resistance de l'arme : " << m_resistanceArme << endl;
	cout << "Energie de l'arme : " << m_energieArme << endl;
	cout << "Xp de l'arme : " << m_xpArme << endl;
}
 
/* Retourne l'energie de l'arme */
double Arme::getEnergie() const
{
	return m_energieArme;
}
 
/* retourne la puissance de l'arme */
double Arme::getPuissance() const
{
	return m_puissanceArme;
}
 
/* retourne la rapidite de l'arme*/
double Arme::getRapidite() const
{
	return m_rapiditeArme;
}
 
/* retourne la resistance de l'arme */
double Arme::getResistance() const
{
	return m_resistanceArme;
}
 
/* Fonction qui permet a l'arme de gagner des Xp */
void Arme::gagnerXp(int& xpRecu)
{
	m_xpArme += xpRecu;
	if(m_xpArme > 1000)
	{
		while(m_xpArme > 1000)
		{
			m_xpArme -= 500;
			m_levelArme += 1;
		}
	}
}

Assassin.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
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
#include "Assassin.h"
#include "Arme.h"
#include <string>
#include <iostream>
using namespace std;
 
/* Fonction qui fait perdre la vie a l'assassin */
void Assassin::perdreHp(double const nbDegat)
{
	/* Si il est vivant, il pourra perdre de la vie */
	if(m_estVivant = true)
	{
		/* Calculer le nombre de dommage sur l'assassin */
		double perte(nbDegat/(m_resistance+m_arme->getResistance()));
		m_hp -= perte;
		/* Si il succombre, il meurt */
		if(m_hp < 0)
		{
			m_estVivant = false;
			cout << "Vous etes mort" << endl;
		}
		else
		{
			cout << "Vous avez perdu " << perte << " vies" << endl;
		}
	}
	else
	{
		cout << "Vous etes mort" << endl;
	}
}
 
/* Fonction qui fait perdre du Sp a l'assassin */
void Assassin::perdreSp(double perte)
{
	/* Si il y a du Sp, il peut en perdre */
	if(m_sp > 0)
	{
		m_sp -= perte;
	}
	else
	{
		cout << "Pas d'energie" << endl;
	}
}
 
/* La fonction qui permet a l'assassin de gagner des Xp */
void Assassin::gagnerXp(int const& levelEnnemi, bool const& ennemiVivant)
{
	/* Si l'ennemi est mort */
	if(ennemiVivant == false)
	{
		/* Calculer le Xp ramasser */
		int gain = levelEnnemi*40;
		gain /= m_level;
		/* Rajouter le Xp gagner */
		m_xp += gain;
		m_arme->gagnerXp(gain);
		cout << "Vous avez gagner " << gain << " xp" << endl;
		/* A chaque 100 xp, tu as un level up */
		if(m_xp > 100)
		{
			while(m_xp > 100)
			{
				m_xp -= 100;
				m_level += 1;
				gagnerHp(ennemiVivant);
				gagnerSp(ennemiVivant);
				m_hp += 100;
				m_sp += 100;
				cout << "Felicitation : vous avez atteint le niveau " << m_level << endl;
			}
		}
	}
}
 
/* Fonction qui permet de gagner des Hp */
void Assassin::gagnerHp(bool const& ennemiVivant)
{
	/* Si l'ennemi meurt, tu recois des vies en recompenses */
	if(ennemiVivant == false)
	{
		/* Calculer le nombre de hp que l'assassin merite */
		double gain((m_rapidite+m_arme->getRapidite())/5);
		/* Ajouter le hp merité */
		m_hp += gain;
		cout << "Vous avez gagner " << gain << " vie." << endl;
	}
}
 
/* Fonction qui permet de ganger des Sp*/
void Assassin::gagnerSp(bool const& ennemiVivant)
{
	/* Si l'ennemi meurt, tu recois des sp en recompenses */
	if(ennemiVivant == false)
	{
		/* Calculer le nombre de sp merité */
		double gain((m_rapidite+m_arme->getRapidite())/5);
		gain *= 2;
		/* Ajouter le nombre de sp merité */
		m_sp += gain;
		cout << "Vous avez gagner " << gain << " sp." << endl;
	}
}
 
/* Fonction qui permet de gagner de la capacite*/
void Assassin::gagnerCapacite(bool const& ennemiVivant)
{
	/* Si l'ennemi meurt, tu recois des capacite */
	if(ennemiVivant == false)
	{
		m_puissance += 5;
		m_resistance += 5;
		m_rapidite += 5;
		m_energie += 5;
		cout << "Vous avez gagner 5 puissances" << endl; 
		cout << "Vous avez gagner 5 resistances" << endl;
		cout << "Vous avez gagner 5 rapidites" << endl;
		cout << "Vous avez gagner 5 energies" << endl;
	}
}
 
/* Fonction qui permet a l'assassin d'attaquer un monstre */
void Assassin::attaquer(Monstre &cible)
{
	cout << "Vous avez attaquer" << endl;
	/* Calculer la force d'impacte */
	double forceDattaque((m_arme->getPuissance()+m_puissance)*2);
	/* Enlever la vie au monstre */
	cible.perdreHp(forceDattaque);
	/* Si il meurt, l'assassin a gagné */
	if(cible.getVivant() == false)
	{
		gagnerXp(cible.getLevel(),cible.getVivant());
		gagnerHp(cible.getVivant());
		gagnerSp(cible.getVivant());
		gagnerCapacite(cible.getVivant());
	}
}
 
/* Fonction qui permet a l'assassin de faire des attaques magiques */
void Assassin::superAttaque(Monstre &cible)
{
	/* Calculer l'energie qui sera utilisé pendant l'attaque */
	double coutEnergie(999/(m_energie+m_arme->getEnergie()));	
	/* Calculer la force d'impacte qui aura */
	double forceDattaque((m_arme->getEnergie()+m_energie)*2*(m_puissance+m_arme->getPuissance()));
	/* Si l'assassin a assez de sp, il pourra faire la super attaque*/
	if(coutEnergie < m_sp)
	{
		cout << "Vous avez faite un super-pouvoir" << endl;
		/* Perdre l'energie consumé */
		perdreSp(coutEnergie);
		/* La cible recoit l'impacte */
		cible.perdreHp(forceDattaque);
		/* Si le monstre meurt, l'assassin a gagné */
		if(cible.getVivant() == false)
		{
			gagnerXp(cible.getLevel(),cible.getVivant());
			gagnerHp(cible.getVivant());
			gagnerSp(cible.getVivant());
			gagnerCapacite(cible.getVivant());
		}
	}
	else
	{
		cout << "Vous n'avez plus d'energie" << endl;
	}
}
 
/* Fonction qui retourne si l'assassin est en vie ou mort */
bool Assassin::getVivant() const
{
	return m_estVivant;
}
 
/* Fonction qui affiche l'information sur l'assassin */
void Assassin::information() const
{
	cout << endl << "Nom : " << m_nom << endl;
	cout << "Classe : " << m_class << endl;
	cout << "Hp : " << m_hp << endl;
	cout << "Sp : " << m_sp << endl;
	cout << "Xp : " << m_xp << endl;
	cout << "Level : " << m_level << endl;
	cout << "Puissance : " << m_puissance << endl;
	cout << "Rapidite : " << m_rapidite << endl;
	cout << "Resistance : " << m_resistance << endl;
	m_arme->information();
}
 
Assassin::~Assassin()
{
	delete m_arme;
}
 
/* Creation d'un assassin */
Assassin::Assassin(std::string& pseudo,char& job)
{
	m_nom = pseudo;
	m_hp = 100;
	m_sp = 100;
	m_xp = 0;
	m_level = 1;
	m_estVivant = true;
	m_arme = 0;
	m_arme = new Arme(job);
	switch(job)
	{
	case 'g':
		m_class = 'g';
		m_puissance = 10;
		m_rapidite = 10;
		m_energie = 10;
		m_resistance = 15;
		break;
	case 'n':
		m_class = 'n';
		m_puissance = 10;
		m_rapidite = 15;
		m_energie = 10;
		m_resistance = 10;
		break;
	case 'h':
		m_class = 'h';
		m_puissance = 10;
		m_rapidite = 10;
		m_energie = 15;
		m_resistance = 10;
		break;
	default:
		m_class = 's';
		m_puissance = 15;
		m_rapidite = 10;
		m_energie = 10;
		m_resistance = 10;
		break;
	}
}
 
/* Assassin par defaut */
Assassin::Assassin() : m_nom("Ken"), m_hp(100), m_sp(100), m_xp(0), m_level(1), m_estVivant(true), m_class('s'), m_puissance(15), m_rapidite(10), m_energie(10), m_resistance(10), m_arme(0)
{
	m_arme = new Arme;
}
 
/* Retourner la class de l'assassin */
char Assassin::getClass() const
{
	return m_class;
}
 
/* Retourne la vie de l'assassin */
double Assassin::getHp() const
{
	return m_hp;
}
 
/* Il affiche la vie & l'energie de l'assassin */
void Assassin::Etat() const
{
	cout << endl << "Hp : " << m_hp << endl;
	cout << "Sp : " << m_sp << endl;
}
 
Assassin& Assassin::operator=(Assassin const& a)
{
	if(this != &a)
	{
		m_nom=a.m_nom;
		m_class=a.m_class;
		m_hp =a.m_hp;
		m_sp=a.m_sp;
		m_xp=a.m_xp;
		m_level=a.m_level;
		m_puissance=a.m_puissance;
		m_rapidite=a.m_rapidite;
		m_energie=a.m_energie;
		m_resistance=a.m_resistance;
		m_estVivant=a.m_estVivant;
		m_arme=a.m_arme;
	}
	return *this;
}

Guerrier.cpp

Code:

1
2
3
4
5
6
7
8
9
10
#include "Guerrier.h"
#include "Assassin.h"
#include <iostream>
#include <string>
using namespace std;
 
Guerrier::Guerrier(std::string &pseudo, char &job)
{
	Assassin(pseudo,job);
}

main.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
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
#include <iostream>
#include <string>
#include "Assassin.h"
#include "Monstre.h"
#include "Arme.h"
#include "Slugger.h"
#include "Ninja.h"
#include "Guerrier.h"
#include "SuperHeros.h"
using namespace std;
 
int main()
{
	/* declarer les variables */
	string pseudo;
	char job;
	int niveauMonstre(1);
	char action;
	Assassin* niggajutsu;
	Monstre* vampire;
	niggajutsu = 0;
	vampire = 0;
 
	/* Creer ton personnage */
	cout << "Quel est le nom de ton personnage?" << endl;
	getline(cin,pseudo);
	cout << "Quel est ta classe?" << endl << "s = slugger" << endl << "g = Guerrier" << endl << "n = ninja" << endl << "h = super-heros" << endl;
	cin >> job;
 
	/* Creer les objets */
	switch(job)
	{
	case 'g':
		niggajutsu = new Guerrier(pseudo,job);
		break;
	case 'n':
		niggajutsu = new Ninja(pseudo,job);
		break;
	case 'h':
		niggajutsu = new SuperHeros(pseudo,job);
		break;
	default:
		niggajutsu = new Slugger(pseudo,job);
		break;
	}
	vampire = new Monstre(niveauMonstre);
 
	/* La bataille */
	cout << "Pour ce battre, il faut faire x = attaque & z = super-attaque." << endl;
 
	do
	{
			/* Afficher les informations sur vous & l'adversaire */
			cout << "---------------------------- New Match ----------------------------" << endl;
			niggajutsu->information();
			vampire->information();
		do
		{
			vampire->attaquer(*niggajutsu); // Le monstre Attaque
			cout << "('_') : A votre tour..." << endl; // Sa affiche que c'est notre tour.
			cin >> action; // on effectue l'action
			if(action != 'x' && action != 'z') // si le joueur n'a pas cliqué sur x ou z
			{
				while(action != 'x' && action != 'z') // tant qu'il ne met pas x ou z
				{
					cout << "Erreur : Vous devez que choisir x ou z" << endl; // on affiche un message d'erreur
					cin >> action; // Puis, il doit mettre x ou z
				}
			}
			if(action == 'x') // si il clique x
			{
				niggajutsu->attaquer(*vampire); // il attaque le monstre
			}
			else if(action == 'z') // si il clique z
			{
				niggajutsu->superAttaque(*vampire); // il fait une superattaque sur le monstre
			}
			niggajutsu->Etat(); // Affiche la vie & l'energie du joueur
			vampire->Etat(); // affiche la vie de l'ennemi
		}while(vampire->getHp() > 0 && niggajutsu->getHp() > 0); // Si quelqu'un meurt, c'est la fin du combat.
		delete vampire;
		niveauMonstre += 1;
		vampire = new Monstre(niveauMonstre);
	}while(niggajutsu->getHp() > 0);
		delete niggajutsu;
		niggajutsu = 0;
		delete vampire;
		vampire = 0;
	system("PAUSE");
	return 0;
}

Monstre.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
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#include "Monstre.h"
#include <iostream>
using namespace std;
 
/* Fonction qui fait perdre de la vie du monstre */
void Monstre::perdreHp(double const nbDegat)
{
	/* Si il est vivant, il pourra perdre des vies*/
	if(m_estVivant = true)
	{
		/* calculer le dommage qui aura sur le monstre */
		double perte(nbDegat/m_resistance);
		m_hp -= perte;
		/* Si il succombre, il meurt */
		if(m_hp < 0)
		{
			m_estVivant = false;
			cout << "Le monstre est mort" << endl;
		}
		else
		{
			cout << "Dommage de " << perte << " vies" << endl;
		}
	}
	else
	{
		cout << "Le monstre est mort" << endl;
	}
}
 
/* Fonction de perdre de l'energie */
void Monstre::perdreSp(double perte)
{
	/* Si il y a du sp, le monstre peut en perdre */
	if(m_sp > 0)
	{
		m_sp -= perte;
	}
	else
	{
		cout << "Le monstre n'as d'energie" << endl;
	}
}
 
/* fonction qui permet au monstre de attaquer un assassin */
void Monstre::attaquer(Assassin &cible)
{
	cout << "Le monstre vous a attaquer" << endl;
	/* Calculer la force d'impacte */
	double forceDattaque(5*m_puissance);
	/* Enlever la vie au assassin */
	cible.perdreHp(forceDattaque);
	/* Si la cible meurt. Le monstre a gagné */
	if(cible.getVivant() == false)
	{
		cout << "Le monstre a gagner" << endl;
	}
}
 
/* fonction qui permet au monstre de faire une attaque magique */
void Monstre::superAttaque(Assassin &cible)
{
	/* Calculer l'energie qui sera depensé lors de l'attaque */
	double coutEnergie(19);
	/* Calculer la force d'impacte qui aura */
	double forceDattaque(3*(m_energie*2*m_puissance));
	/* Si le monstre a assez d'energie. Il peut faire la super attaque. */
	if(coutEnergie < m_sp)
	{
		cout << "Le monstre a fait un superpouvoir" << endl;
		/* Perdre l'energie consumé */
		perdreSp(coutEnergie);
		/* La cible recoit l'impacte */
		cible.perdreHp(forceDattaque);
		/* Si l'assassin succombre le monstre gagne */
		if(cible.getVivant() == false)
		{
			cout << "Le monstre a gagner." << endl;
		}
	}
	else
	{
		cout << "Le monstre n'a plus d'energie" << endl;
	}
}
 
/* Fonction qui retourne le level du monstre */
int Monstre::getLevel() const
{
	return m_level;
}
 
/* Fonction qui retourne si le monstre est en vie ou pas */
bool Monstre::getVivant() const
{
	return m_estVivant;
}
 
/* Fonction qui affiche les informations du monstres */
void Monstre::information() const
{
	cout << endl << "Hp : " << m_hp << endl;
	cout << "Sp : " << m_sp << endl;
	cout << "Level : " << m_level << endl;
	cout << "Puissance : " << m_puissance << endl;
	cout << "Rapidite : " << m_rapidite << endl;
	cout << "Resistance : " << m_resistance << endl << endl;
}
 
/* Creation d'un monstre */
Monstre::Monstre(int const& niveauMonstre)
{
	m_level = niveauMonstre;
	m_hp = 15+(5*m_level);
	m_sp = 15+(5*m_level);
	m_puissance = 5*m_level;
	m_rapidite = 5*m_level;
	m_energie = 5*m_level;
	m_resistance = 5*m_level;
	m_estVivant = true;
}
 
/* Monstre par defaut */
Monstre::Monstre() : m_level(1), m_hp(20), m_sp(20), m_puissance(5), m_rapidite(5), m_energie(5), m_resistance(5), m_estVivant(true)
{
}
 
/* Il retourne le hp du monstre */
double Monstre::getHp() const
{
	return m_hp;
}
 
/* Il affiche la vie du monstre */
void Monstre::Etat() const
{
	cout << endl << "Hp : " << m_hp << endl;
}

Ninja.cpp

Code:

1
2
3
4
5
6
7
8
9
10
#include "Ninja.h"
#include "Assassin.h"
#include <iostream>
#include <string>
using namespace std;
 
Ninja::Ninja(std::string &pseudo, char &job)
{
	Assassin(pseudo,job);
}

Slugger.cpp

Code:

1
2
3
4
5
6
7
8
9
10
#include "Slugger.h"
#include "Assassin.h"
#include <iostream>
#include <string>
using namespace std;
 
Slugger::Slugger(std::string &pseudo, char &job)
{
	Assassin(pseudo,job);
}

SuperHeros.cpp

Code:

1
2
3
4
5
6
7
8
9
10
#include "SuperHeros.h"
#include "Assassin.h"
#include <iostream>
#include <string>
using namespace std;
 
SuperHeros::SuperHeros(std::string &pseudo, char &job)
{
	Assassin(pseudo,job);
}

Je sais que c'est beaucoup de fichier mes sa m'aiderais beaucoup. Merci