在基本的C ++攻击游戏中需要帮助实现Health

Question

The main value of this extremely simple attack game (for me) is to familiarize myself with simple polymorphism, and to practice using pointers. With that said, I would love to add onto it. Looking at my program, I'm not sure If I should create a separate "Hero" class, and to just have that inherit from the "Character" class, or if I should just assume that the Hero IS the "Character" class, which the enemies inherit from. The only thing I want to do right now is to implement something where the Hero's health decreases after attack. Sorry if it's very rudimentary, I'm just trying to get the basics down.

Thanks.

#include <iostream>
#include "Character.h"

using namespace std;

int main() {

    Ninja n;
    Dragon d;

    Character *enemy1 = &n;
    Character *enemy2 = &d;

    enemy1->setAttackPower(20);
    enemy2->setAttackPower(40);

    n.attack();
    d.attack();

    return 0;
}


//Character.h
#include <iostream>

using namespace std;

class Character 
{
    protected:

    int Health = 100;
    int attackpower;

    public:

    void setAttackPower(int attack) {
        attackpower = attack;
    }
};

class Ninja: public Character
{
    public:

    void attack() {
        cout << "Ninja attacks your character! - " << attackpower << " Points!" << endl;
    }
};

class Dragon: public Character
{
    public:

    void attack() {
        cout << "Dragon attacks your character! - " << attackpower << " Points!" << endl;
    }
};

Answer 1

I am having some trouble identifying specific questions in your post, but there are some suggested questions. Namely, how do you make a hero character and have him 'fight' these other characters. For one, you need a hero character. This can indeed just be another child of Character. Second, attack actually needs to specify a target.

n.attack()

is all well and good, but what is he attacking? That isn't an issue right now because all attack does is print, but you want it to do more. You want it to attack a particular character, so you should make it take a character as an argument

void attack ( Character &char )
or
void attack ( Character *char )

for instance.

Now, there are two big issues. It seems you made this for polymorphism testing, but you're not really fully exploiting it. First, you should promote attack to be an abstract virtual function in Character:

class Character {
public:
  virtual void attack ( Character *char ) = 0;

};

class Ninja {
public:
  virtual void attack ( Character *char) 
  {

  }
};

Also, now you can use polymorphism when calling attack on your characters:

enemy1->attack(Hero);
enemy2->attack(Hero);

Answer 2

Change your attack function to take a pointer to the targeted character, then you can reduce the targeted character's health. You'll be able to access the protected health data of the target directly.

void attack(Character* target)
{
  //specific printouts...
  target->Health -= attackpower;
}

Another pattern to use is to keep the generic code in the base class and then from there call a derived function that does character specific things, like:

class Character
{
  //...
  void attack(Character* target)
  {
    target->Health -= attackpower;
    DerivedAttack();
  }

  virtual void DerivedAttack() = 0;

};

class Dragon:public Character
{
  //...
  void DerivedAttack()
  {
    cout << "Dragon attacks your character! - " << attackpower << " Points!" << endl;
  }
};

Answer 3

I think that the best use of polymorphism is the one that matches what we think in real life.

So, I would suggest you have the Character class which has all the common features of a hero and an enemy. Then you have two separate classes (the Hero class and the Enemy class) both inherit from Character . However, each implements its own specific methods unique to Heros and Enemies.

Example of things in Character class: attack power and health (like you have in your code)

Example of things in Hero and Enemy class: image of the enemy or hero (or special unique weapon for the hero), etc.

Hence, the code you provided with the Ninja and Dragon makes a lot of sense to me.