Irrlicht Engine

Code: Select all

initShaders(video);

levelManager levelMgr(smgr);
weatherManager weatherMgr(smgr);
grassManager grassMgr(smgr);
treeManager treeMgr(smgr);
weaponManager weaponMgr(smgr);
UIManager UIMgr(device);
npcManager npcMgr(smgr);

levelMgr.loadLevel("./data/levels/example/level.irr");
levelMgr.setLevelFog(SColor(0,128,128,128), 200, 800);

weatherMgr.initWeather();

weaponMgr.loadWeapons("./data/config/weapons.xml");

player* player1= new player(smgr, timer);
player1->setPrimaryWeapon(weaponMgr.createWeaponFromIndex(0), camera);
player1->setSecondaryWeapon(weaponMgr.createWeaponFromIndex(1), camera);

UIMgr.setActivePlayer(player1);
UIMgr.init();

npcMgr.setTerrain((ITerrainSceneNode*)smgr->getSceneNodeFromType(ESNT_TERRAIN));
...

Code: Select all

class Game
{

public:

bool init() { /* init device here */ }

irr::IrrlichtDevice* getIrrlichtDevice() const { return device; }

private:

irr::IrrlichtDevice* device;
Physics* physics;
};

Code: Select all

class Player
{

public:

Player(Game* game) :
    game(game)

private:

Game* game;
};

Code: Select all

class Game; //forward declaration

class Player
{

}

Code: Select all

  #include <irrlicht.h>

using namespace irr;
using namespace core;

//the message interface to be sent
class IMessage {
  public:
    virtual u32 getCode()=0;
};

//the receiver interface that handles messages
class IMessageReceiver {
  public:
    virtual void handleMessage(IMessage *aMessage)=0;
    virtual void queueDestroyed()=0;
};

//the messaging queue
class CMessageQueue {
  protected:
    list<IMessageReceiver *> m_lReceivers;

  public:
    ~CMessageQueue() {
      list<IMessageReceiver *>::Iterator it;
      for (it=m_lReceivers.begin(); it!=m_lReceivers.end(); it++) (*it)->queueDestroyed();
    }

    void addReceiver(IMessageReceiver *p) {
      //first make sure one receiver is only added once
      list<IMessageReceiver *>::Iterator it;
      for (it=m_lReceivers.begin(); it!=m_lReceivers.end(); it++) if ((*it)==p) return;
      printf("CMessageQueue::addReceiver: adding receiver\n");
      m_lReceivers.push_back(p);
    }

    void removeReceiver(IMessageReceiver *p) {
      list<IMessageReceiver *>::Iterator it;
      for (it=m_lReceivers.begin(); it!=m_lReceivers.end(); it++) {
        printf("CMessageQueue::removeReceiver: removing receiver\n");
        m_lReceivers.erase(it);
        return;
      }
    }

    void postMessage(IMessage *pMsg) {
      list<IMessageReceiver *>::Iterator it;
      printf("distributing message\n");
      for (it=m_lReceivers.begin(); it!=m_lReceivers.end(); it++)
        (*it)->handleMessage(pMsg);
    }
};

//an implementation of the message to send a text string
class CTextMessage : public IMessage {
  protected:
    stringc m_sText;

  public:
    CTextMessage(stringc sText) { m_sText=sText; }
    virtual ~CTextMessage() { }
    virtual u32 getCode() { return 23; }
    stringc getText() { return m_sText; }
};

//The actual receiver
class CReceiver : public IMessageReceiver {
  protected:
    CMessageQueue *m_pQueue;

  public:
    CReceiver(CMessageQueue *pQueue) { pQueue->addReceiver(this); m_pQueue=pQueue; }
    virtual ~CReceiver() { if (m_pQueue) m_pQueue->removeReceiver(this); else printf("queue destroyed!\n"); }

    virtual void handleMessage(IMessage *aMessage) {
      if (aMessage->getCode()==23) {  //the code of the text message
        CTextMessage *p=(CTextMessage *)aMessage;
        printf("text received: \"%s\"\n",p->getText().c_str());
      }
    }

    //make sure we don't try to remove the receiver from a deleted queue
    virtual void queueDestroyed() { m_pQueue=NULL; }
};

int main(void) {
  //create queue, receiver and a test text message
  CMessageQueue *pQueue=new CMessageQueue();
  CReceiver *pReceiver=new CReceiver(pQueue);
  CTextMessage *pMsg=new CTextMessage("Hello World");

  //post the message to all registered receivers
  pQueue->postMessage(pMsg);

  //cleanup
  delete pMsg;
  delete pReceiver;
  delete pQueue;

  return 0;
}

Code: Select all

class Crenderer; //forward declaration