What is the proper way to communicate between member classes? - c++

Question

I'm writing an RPG, and the basic code is below. Each player is supposed to have four stats: earth, air, fire, and water. The problem is this: if fire is less than zero, it should spill over into damage to earth. Here is my code so far:
//DANCE GAME
#include <iostream>
using namespace std;
class element {
public:
//get primary magnitude
int gpm(){
return pm;
};
//set primary magnitude
int spm(int x){
pm = x;
};
protected:
//primary magnitude
int pm;
};
class fire : public element {
};
class earth : public element {
};
class soul {
public:
earth e;
fire f;
};
int main () {
soul p1, p2;
p1.e.spm(5);
cout << p1.e.gpm() << endl;
p1.f.spm(5);
cout << p1.f.gpm() << endl;
return 0;
};
So, I want each element to have a unique spm() function to control its special behavior. For fire, it should have the effect of the pseudocode below:
fire.spm(int x)
pm += x
if pm < 0
x = abs(pm)
pm = 0
owner.earth -= x
Obviously it's that last line that's giving me problems. What is the proper way to accomplish such a thing?

Answer 1

You should pass owner as argument to method spm.

Answer 2

Obviously it's that last line that's giving me problems. What is the proper way to accomplish such a thing?
There is a guide line that states that you should not work on another object's data (Law of Demeter). Instead, you should propagate the changes downwards, from objects that know everyone else, to objects that know only how to handle their own data.
This means that your fire element implementation should not know that a soul has an earth element (let alone try to alter it directly). It is instead the responsibility of the soul to propagate these changes (because a soul instance knows both earth and fire classes).
Based on this, you should consider something like this:
class element
{
public:
// update primary magnitude, taking hints from the provided element
// if this->get_type() == other.get_type()
// at the end of the operation, primary_magnitude_ should be
// other.primary_magnitude_;
virtual void update(const element& other)
{
if(get_type() == other.get_type())
set_magnitude(other.magnitude());
}
protected:
enum { earth_type, fire_type, air_type, water_type } element_type;
virtual element_type get_type() const = 0;
int magnitude() const { return primary_magnitude_; }
void update_magnitude(int delta) { primary_magnitude_ += delta; }
void set_magnitude(int value) { primary_magnitude_ = delta; }
private:
int primary_magnitude_;
};
class earth
{
public:
void update(const element& other) override
{
switch(other.get_type())
{
case element::earth_type:
set_magnitude(other.magnitude());
break;
case element::fire_type:
update_magnitude( std::min(0, other.magnitude()) );
break;
}
}
protected:
element_type get_type() const override { return element::earth_type; }
};
class soul
{
public:
void update(const element& value)
{
earth_.update(value);
fire_.update(value);
}
private:
earth earth_;
fire fire_;
};

Answer 3

spm means "set primary magnitude". Two notes on this. First, it's better to call function SetPrimaryMagnitude or set_primary_magnitude if the function is supposed to actually set the primary magnitude. It makes life so much easier. BTW, element class has only one value, pm, so I don't see the need to call that value "primary". I mean, what would be "secondary"?
Second, you actually don't want to set that value but to have a combination of actions that increase, decrease, and spill the difference to yet another value. Maybe it would be better to call such action "adjust". And make it a member of soul (if that class is the only one that handles the math this specific way). Something like this:
soul::AdjustElementValues(element& primary, element& secondary, int value)
{
// decrease primary by value, and if needed spill the remains to secondary
}
If soul is not the only class that does this math, then move the math to separate class, which has access to all needed objects. Say, class element_spiller with constructor that takes pointers to two elements, primary and secondary, and has a method that takes int value argument and changes the elements accordingly.