node.cpp:116: error: cannot declare variable `receiver' to be of type `CEventReceiver'
node.cpp:116: error:   because the following virtual functions are abstract:
C:/Program Files/CodeBlocks/include/IRR/IEventReceiver.h:256: error:  virtual bool irr::IEventReceiver::OnEvent(const irr::SEvent&)

#include "CEventReceiver.h"

using namespace irr;
//-------------------------------------------------------------------------------

void closeDevice();
 //---------------------------------------------------------------------------------
 // 2 fonctions toutes nulles pour tester que le perso bouge , tourne et avance
void moveISceneNode(scene::ISceneNode* node,core::vector3df  vector)
{
     node->getRelativeTransformation().rotateVect(vector);
     node->setPosition(  node->getPosition()+vector);

}
void turnISceneNode(scene::ISceneNode* node,core::vector3df vector)
{
     node->setRotation( node->getRotation()+vector);
}

int main(void)
{

    IrrlichtDevice* device = createDevice(video::EDT_OPENGL, core::dimension2d<s32>(640, 480), 16,false,false,false);
      video::IVideoDriver* driver = device->getVideoDriver ();
    scene::ISceneManager* scenegraph = device->getSceneManager ();
    scene::ISceneManager* smgr = device->getSceneManager();
    irr::scene::ISceneManager *sceneManager = device->getSceneManager ();

    //On rend invisible le curseur
    device->getCursorControl ()-> setVisible (false);



 scene::IAnimatedMesh *room = scenegraph->getMesh("room.3ds");
    if (room == 0)
    {
        std::cout << "problème de chargement de la salle" << std::endl;
        return 1;
    }
    scene::ImeshSceneNode *Nroom = scenegraph->addMeshSceneNode(room->getMesh(0));
    Nroom->setPosition(core::vector3df(0,-80,0));
//On applique une texture à la salle.
    scenegraph->getMeshManipulator()->makePlanarTextureMapping(
        room->getMesh(0), 0.004f);
    Nroom->setMaterialTexture( 0, driver->getTexture("rockwall.bmp") );





        //On cree la keymap associe a la camera
    irr::SKeyMap keyMap[5];
    //avancer
    keyMap[0].Action = irr::EKA_MOVE_FORWARD;
    keyMap[0].KeyCode = irr::KEY_KEY_Z;
    //reculer
    keyMap[1].Action = irr::EKA_MOVE_BACKWARD;
    keyMap[1].KeyCode = irr::KEY_KEY_S;
    //a gauche
    keyMap[2].Action = irr::EKA_STRAFE_LEFT;
    keyMap[2].KeyCode = irr::KEY_KEY_Q;
    //a droite
    keyMap[3].Action = irr::EKA_STRAFE_RIGHT;
    keyMap[3].KeyCode = irr::KEY_KEY_D;
    //saut
    keyMap[4].Action = irr::EKA_JUMP_UP;
    keyMap[4].KeyCode = irr::KEY_SPACE;



scene::ITriangleSelector* selector = 0;

//et tu lui associ le node :
selector = smgr->createOctTreeTriangleSelector(room->getMesh(0), Nroom, 128);
Nroom->setTriangleSelector(selector);
selector->drop();


    //Sydney
    irr::scene::IAnimatedMeshMD2* modele;
    modele = (irr::scene::IAnimatedMeshMD2*)sceneManager->getMesh("sydney.md2");
    irr::scene::IAnimatedMeshSceneNode* Nmodele =
    sceneManager->addAnimatedMeshSceneNode(modele);

    //On modifie les proprietes de Sydney
    Nmodele->setMaterialFlag(irr::video::EMF_LIGHTING, false);
    Nmodele->setFrameLoop(0, 0);
    Nmodele->setMaterialTexture( 0, driver->getTexture("sydney.bmp") );

   // creation de la cam , rien de mystique
   scene::ICameraSceneNode * camera=smgr->addCameraSceneNode(Nmodele,core::vector3df(0,0,0),core::vector3df(0,0,0));
   // on place la cam en 0,20,-30 qui sont des coords locals mais comme le cube n'a pas bouger elles correspondent au coord global ie par rapport a 0
   camera->setPosition(core::vector3df(0,20,-30));

//puis tu lui associ la collision avec comme surface "selector" :
scene::ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(
selector, camera, core::vector3df(50,50,50),
core::vector3df(0,-1,0),
core::vector3df(0,0,0));
camera->addAnimator(anim);
anim->drop();



   //lumiere
    scene::ILightSceneNode* lum1 = scenegraph->addLightSceneNode(Nroom, core::vector3df(150,210,250),video::SColorf(0.4f, 0.4f, 0.4f, 0.4f), 30.0f);



    //On cree le capteur d'event et on l'associe au device.


CEventReceiver receiver(Nmodele);
    device->setEventReceiver(&receiver);
    //La boucle de rendu

    while (device->run())
    {
                  //la cam look le cube
          camera->setTarget(Nmodele->getPosition());
              driver->setFog(video::SColor(0,215,215,224), false, 2.0,200.0,0.01, true);
        driver->beginScene(true,true,video::SColor(0,200,200,200));
        //Met a jour la position du mesh
        //Met a jour la position du mesh
        receiver.majPosMesh();
        scenegraph->drawAll ();
        driver->endScene ();
        device->setWindowCaption(L"room");


}

    device->drop ();
    return 0;
}

#include "CEventReceiver.h"


CEventReceiver::CEventReceiver(irr::scene::IAnimatedMeshSceneNode* Nmodele)
{
    //On pointe le mesh passe en parametre.
    m_Nmodele = Nmodele;
    //Par defaut on ne bouge pas
    m_isMoving = false;
}


bool CEventReceiver::OnEvent(irr::SEvent event)
{
    //On verifie que le pointeur est ok
    if(m_Nmodele != 0
    //Qu'il s'agit d'un event concernant un appui/relachement de touche
    && event.EventType == irr::EET_KEY_INPUT_EVENT
    //Qu'il s'agit d'un appui
    && event.KeyInput.PressedDown == true
    //Qu'il s'agit de la touche z
    && event.KeyInput.Key == irr::KEY_KEY_Z)
    {
        //Si on n'est pas en train de bouger, on s'y met
        if(m_isMoving == false)
            m_isMoving = true;
        //L'event est traite, on retourne true
        return true;
    }


    if(m_Nmodele != 0
    && event.EventType == irr::EET_KEY_INPUT_EVENT
    && event.KeyInput.PressedDown == false
    && event.KeyInput.Key == irr::KEY_KEY_Z)
    {
        //La touche est relachee, on arrete de bouger
        m_isMoving = false;
        return true;
    }

    //Si on arrive la, c'est qu'on a pas traite l'event
    return false;
}


void CEventReceiver::majPosMesh()
{
    //On verifie que le pointeur vers le mesh est
    //ok et que la touche est enfoncee
    if(m_Nmodele != 0 && m_isMoving == true)
    {
        //On commence par recuperer la position actuelle
        irr::core::vector3df v = m_Nmodele->getPosition();
        //On y ajoute la valeur de deplacement
        v.X += 1.0f;
        //On renvoie la nouvelle position
        m_Nmodele->setPosition(v);
    }
}

#include <irr/irrlicht.h>
#include <IEventReceiver.h>
#include <iostream>

class CEventReceiver : public irr::IEventReceiver
{

public :

    //Le constructeur.
    CEventReceiver(irr::scene::IAnimatedMeshSceneNode* Nmodele);
    //Capte automatiquement les events.
    bool OnEvent(irr::SEvent event);
    //Met a jour la position du mesh.
    void majPosMesh();


private :

    //Le modele qu'on va controler.
    irr::scene::IAnimatedMeshSceneNode* m_Nmodele;
    //Indique si on est deja en mouvement ou pas.
    bool m_isMoving;
};