Question

I am having a problem with the following code, the overriden virtual functions are not executing. Not sure i’m doing wrong here probably a silly mistake. Anyway this is a game project and I have an array of objects which looks like this (the core::array is an irrlicht array, similar to the vector array)

core::array<GameObject> gameTargets;

This is the GameObject and Zombie definition

class GameObject {
protected:
    scene::ISceneNode* node;
public:
    int ID;
    int hitpoints;

    GameObject() {
        ...
    };

    void setNode(scene::ISceneNode* inode) {
        ...
    }

    virtual void shot(int dmg) {
        ... [BREAKPOINT HERE]
    }

    scene::ISceneNode* getNode() {
        return node;
    }
};

class Zombie : public GameObject {
public:
    static const enum Animation {
        ZOMBIE_WALK,
        ZOMBIE_HURT,
        ZOMBIE_DIE,
        ZOMBIE_TWITCH,
        ZOMBIE_ATTACK,
        ZOMBIE_IDLE
    };

    //We only want to accepted animated mesh nodes for this object
    Zombie(int hp, scene::IAnimatedMeshSceneNode* inode) {
        ...
    }

    //Override the shot function
    void shot(int dmg) {
        ... [BREAKPOINT HERE]
    }

    //Animate the zombie
    void setAnimation(Animation anim) {
        ...
    }
};

The member functions of the derived classes is never called, I am creating the objects like this

Zombie target(hp, (scene::IAnimatedMeshSceneNode*)node);

and calling the virtual function like this

for(int i = 0; (u32)i<level->gameTargets.size(); i++) {
    if(selectedNode == level->gameTargets[i].getNode()) {
        level->gameTargets[i].shot(b->damage);
    }
}

where b is a pointer to a bullet with a int variable damage and gameTargets contains GameObject

Answer 1

I suspect that you’re experiencing slicing because the gameTargets array contains values. I can’t tell for sure because I don’t know how the core::array template works. See What is object slicing? for a discussion about what slicing is.

To fix this problem, store either raw pointers as in

core::array<GameObject *> gameTargets;

Or use some sort of reference-counted pointer like

core::array<std::shared_ptr<GameObject>> gameTargets; // only available in C++11