Irrlicht Engine

Code: Select all

class Item
{
    (...)
    virtual void whoAmI()
    {
        std::cout << "ITEM!" << std::endl;
    }
}
 
class Weapon : public Item
{
    (...)
    virtual void whoAmI()
    {
        std::cout << "WEAPON!" << std::endl;
    }
}

Code: Select all

Weapon w;
Item* item = &w;
item->whoAmI();

Code: Select all

"WEAPON!"

Code: Select all

virtual void foo();

Code: Select all

virtual void foo() = 0;

Code: Select all

 
class executionUnit
{
//constructor... nothing in it
executionUnit() {}
 
virtual ~executionUnit() {} 
//it is important to define this virtual even if it is empty, because the destructors have special rules with regard to polymorphism
//they are called in cascade from child to parent class, instead of only that of the child class.
 
virtual bool init() = 0;
 
virtual bool run() = 0;
 
virtual void clean() = 0;
 
};
 

Code: Select all

 
void main()
{
int i = 0;
executionUnit* unit;
//...i create the main,screen1 and screen2 objects...
 
main->init(); //safe initialization ;)
unit = main; //It is a legal assignment, unit is of the base class of main.
//from now on, we care little of what our unit pointer is aiming to... all of the child classes work the same, isn't it?
 
while(unit->run())
{
unit->clean();
 
switch(i%3)
{
case 0:
unit = main;
break;
 
case 1:
unit = screen1;
break;
 
case 2:
unit = screen2;
break;
}
 
unit->init();
++i;
}
//This ends when the unit class returns false in the run call... 
//See how we have created a program that runs 3 small "execution units" (hence the name) in "parallel" :)
 
}
 

Code: Select all

class InventoryItem {
    std::string title;
public:
    InventoryItem(std::string title) : title(title) {}
    virtual void drawIcon(int x, int y); // no default icon
    virtual void drawTooltip(int x, int y); // no default tooltip
};
 
class BronzeHelmet : public InventoryItem {
public:
    BronzeHelmet() : InventoryItem("Bronze Helmet") {}
    virtual void drawIcon(int x, int y) { /* ... */ }
    virtual void drawTooltip(int x, int y) { /* ... */ }
};
 
class SilverBlade : public InventoryItem {
public:
    SilverBlade() : InventoryItem("Silver Blade") {}
    virtual void drawIcon(int x, int y) { /* ... */ }
    virtual void drawTooltip(int x, int y) { /* ... */ }
};
 
int main(int argc, char* argv[])
{
    std::vector<InventoryItem> items;
    //items.push_back(InventoryItem()); // this is invalid, since InventoryItem has at least one pure virtual method
    // (and this is just what we need: we shouldn't allow adding pure InventoryItem -- it is too abstact; and OOP helps us here -- we can add only inheriters)
    items.push_back(BronzeHelmet());
    items.push_back(SilverBlade());

Code: Select all

virtual bool stackable() { return false; } // by default item is not stackable
virtual InventoryItem* getstack(int count) { throw new std::exception(); } // by default it is illegal to call this method since item is not stackable

Code: Select all

class GoldenCoin : public InventoryItem {
    int stackcount;
public:
    GoldenCoin() : InventoryItem("Golden Coin"), stackcount(20) {}
    virtual void drawIcon(int x, int y) { /* ... */ }
    virtual void drawTooltip(int x, int y) { /* ... */ }
    virtual bool stackable() { return true; }
    virtual InventoryItem* getstack(int count) {
        if (count > stackcount + 1) throw new std::exception(); // we cannot return more than we have, and we cannot left less than 1 after all
        GoldenCoin* c = new GoldenCoin();
        c->stackcount = count;
        stackcount -= count;
        return c;
    }
};

Code: Select all

items.push_back(GoldenCoin());

Code: Select all

    if (items[i].stackable()) {
        int userUnstackCountDesire = 5; // here we should ask how many items he want... lets say we know that now for simplicity        
        InventoryItem* j = items[i].getstack(userUnstackCountDesire);
        // now we need to attach j to the mouse pointer so user can place stack where he want it to be
    } else {
        // this InventoryItem doesn't support stacking
        // lets be patient to user's random shift+clicks and instead of throwing an exception here, we just ignore it :)
        return;
    }