You can use a pointer to an abstract class. If your code doesn't work, the error is coming from somewhere else. However...
First modification: replace the get/set pairs with the following.
struct Attributes{ int dexterity, agility, vitality, strength, wisdom, luck; // Apply a set of attribute modifiers to another Attributes &operator += (const Attributes & o);};class AttributeOwner{ private: Attributes basic, effective; public: // Initialize with some attributes AttributeOwner(const Attributes&); // Returns "basic" const Attributes &getBasicAttributes() const; // Returns "effective" const Attributes &getEffectiveAttributes() const; // Adds some modifiers (this alters the effective // attributes, not the basic ones). void addModifiers(const Attributes &); // Add some permanent modifiers (this alters both // basic and effective attributes). void addPermanentModifiers(const Attributes &); // Clear all non-permanent modifiers (sets effective = basic) void clearModifiers();};class Creature : private AttributeOwner { public: using AttributeOwner::getBasicAttributes; using AttributeOwner::getEffectiveAttributes; using AttributeOwner::addModifiers; using AttributeOwner::addPermanentModifiers; using AttributeOwner::clearModifiers; // [rest of the class]};
Now, you've replaced 18 members with only 7 (and only 5 public interface functions) yet you now have additional semantics which allow you to apply temporary modifiers to your characters, and are also more flexible.
Second modification: don't use pointers, because the ownership policy is unknown. Does a Creature own its inventory and equipment, or does it merely reference an externally available object? What happens when you copy-construct a creature? In this particular case, I would personally use std::list and just be done with it. I would also drop the get/set pairs and use:
class InventoryOwner{public: // boost::shared_ptr is useful to get sane and easily implemented // behavior. Use naked pointers if you wish, but it will be harder. typedef boost::shared_ptr<items::Item> item_type; typedef boost::shared_ptr<items::Equipable> equip_type;private: std::list< item_type > items; std::list< equip_type > equipment;public: void equip(const equip_type &); void remove(const equip_type &); void pickUp(const item_type &); void drop(const item_type &); const std::list< item_type > &carried() const; const std::list< equip_type > &equipped() const;};class Creature : private AttributeOwner, private InventoryOwner{public: using AttributeOwner::getBasicAttributes; using AttributeOwner::getEffectiveAttributes; using AttributeOwner::addModifiers; using AttributeOwner::addPermanentModifiers; using AttributeOwner::clearModifiers; using InventoryOwner::equip; using InventoryOwner::remove; using InventoryOwner::pickUp; using InventoryOwner::drop; using InventoryOwner::carried; using InventoryOwner::equipped; // [Rest of the class]};
: remove the stats computation from the object. You don't want to have to inherit an entire fat class just to overload a few bits of behavior. Plus, you'll reduce coupling.
class Stats{public: virtual unsigned int attack(const class Creature &) const = 0; virtual unsigned int defense(const class Creature &) const = 0; virtual unsigned int magicAttack(const class Creature &) const = 0; virtual unsigned int magicDefense(const class Creature &) const = 0; virtual unsigned int maxLife(const class Creature &) const = 0; virtual unsigned int maxSynergy(const class Creature &) const = 0; virtual ~Stats();};class StatsOwner{ boost::shared_ptr< Stats > stats; // Weak pointer const class Creature *c; unsigned int current_life, current_synergy;public: StatsOwner(const class Creature*, const boost::shared_ptr<Stats> &); unsigned int attack() const; unsigned int defense() const; unsigned int magicAttack() const; unsigned int magicDefense() const; unsigned int maxLife() const; unsigned int maxSynergy() const; unsigned int life() const; unsigned int synergy() const; void addLife(int); void addSynergy(int); // Runtime change of the stats. void changeStats(const boost::shared_ptr<Stats> &);};class Creature : private AttributeOwner, private InventoryOwner, private StatsOwner,{public: using AttributeOwner::getBasicAttributes; using AttributeOwner::getEffectiveAttributes; using AttributeOwner::addModifiers; using AttributeOwner::addPermanentModifiers; using AttributeOwner::clearModifiers; using InventoryOwner::equip; using InventoryOwner::remove; using InventoryOwner::pickUp; using InventoryOwner::drop; using InventoryOwner::carried; using InventoryOwner::equipped; using StatsOwner::attack; using StatsOwner::defense; using StatsOwner::magicAttack; using StatsOwner::magicDefense; using StatsOwner::maxLife; using StatsOwner::maxSynergy; using StatsOwner::life; using StatsOwner::synergy; using StatsOwner::addLife; using StatsOwner::addSynergy; using StatsOwner::changeStats; // [Rest of the class]};
: move the 'Move/Rotate/Animate' virtual functions to a controller class which independent of the underlying model. This way, you can change the corresponding behavior at will. I would use the same process as for the StatsOwner here.
Once this is done, your Creature class has no reason to be an abstract base class anymore. Simply configure its behavior by providing it with a construction-time description of tis properties.
