/*
This tutorial will show how to implement a camera and character display which is a copy of the
one used in World of Warcraft.
Its purpose is to offer the Community an example for a camera and movement system for rpg or 
as a base to develop theyr own movement/camera system.

It is based on the irrlicht Tutorial 12 and 
NightBirds NWN Camera example http://irrlicht.sourceforge.net/phpBB2/viewtopic.php?t=3245

Atm its all a bitt messy and very unclean but its still work in progress , althought comments 
or suggestions are always welcome.
You can contact me in the Irrlicht Forums
Username: Jonchaos
or per Email
Antharon@Hotmail.com
*/
#include <irrlicht.h>
#include <iostream>

using namespace irr;

#pragma comment(lib, "Irrlicht.lib")

#define CAMERASPEED 0.1f
#define PI 3.14159265f
#define WIDTH 1024

class Golem
{
public:
    Golem(){       
       this->gIsRunning = false;
       this->gIsAttacking = 0;
       this->gIsAttacked = 0;
       life = 100;
       }
void Pain()
{
       if (this->gIsAttacked == 1)
       {
       this->gIsAttacked++;
       }
}    
private:
        bool gIsRunning;
        int gIsAttacking;
        int gIsAttacked;
        int life;
};
       
class MyEventReceiver : public IEventReceiver
{
public:

    MyEventReceiver(scene::ISceneNode* terrain ,
                    scene::IAnimatedMeshSceneNode* ptrCharacter,
                    IrrlichtDevice* ptrDevice,
                    scene::ICameraSceneNode* ptrCamera)
    {
        // store pointer to terrain so we can change its drawing mode
        this->Terrain = terrain;
        this->Character = ptrCharacter;
        this->device = ptrDevice;
        this->pCamera = ptrCamera;
        this->m_yRotationAngle = 3.14159265*0.5f;
        this->distance = 130;
        this->bIsRunning = false;
        this->bIsAttacking = 0;
        
    }


    
    void Update() 
    { 
        if (!pCamera || !Character) return;


        if (m_lastTargetPos != Character->getPosition()) 
        {
            m_updated = true;
            m_lastTargetPos = Character->getPosition();
        }
        
        if (m_updated) 
        {
            m_updated = false;
            irr::core::vector3df m_Camerapos = m_lastTargetPos;
            m_Camerapos.X += distance*sin(m_yRotationAngle);
            m_Camerapos.Z += distance*cos(m_yRotationAngle);
            m_Camerapos.Y += distance;
            pCamera->setPosition(m_Camerapos);
            pCamera->setTarget(m_lastTargetPos);
        }
}

void attack()
{
                if (this->bIsAttacking != 0){
                this->bIsAttacking ++;
                }
                if (this->bIsAttacking >= 105)
                {
                this->bIsAttacking = 0;
                if(!this->bIsRunning){
                Character->setMD2Animation(scene::EMAT_STAND);
                }else{
                Character->setMD2Animation(scene::EMAT_RUN);
                }
                }
                if (this->bIsAttacking == 1)
                {
                  
                }
                
}
void Zoom(float amount) 
{
    distance *= amount;
    if (distance == 0) distance = 2; //there should be more elaborate capping of things here..
    m_updated = true;
}

    bool OnEvent(SEvent event)
    {        
        Update();

        if (event.EventType == EET_MOUSE_INPUT_EVENT) 
            {
                switch (event.MouseInput.Event) 
                {
                    case EMIE_MOUSE_WHEEL:
                        Zoom(((-event.MouseInput.Wheel)+1)/2+.5f); //make it be from .5 to 1.5
                        return true;
                        break;

                } ;
        }
        
        if (event.EventType == irr::EET_KEY_INPUT_EVENT && !event.KeyInput.PressedDown)
        {
            switch (event.KeyInput.Key)
            {
            case irr::KEY_ESCAPE:
                this->device->closeDevice(); 
                return true;
            }
        }        
        if (event.EventType == irr::EET_KEY_INPUT_EVENT && event.KeyInput.PressedDown  )
        {
            switch (event.KeyInput.Key)
            {        
            case irr::KEY_UP:
                Charpos    = Character->getPosition();
                Charpos.X = Charpos.X - 10.0f ;
                Character->setPosition(Charpos); 
                Character->setRotation(core::vector3df(0,180,0));
                if (!this->bIsRunning)
                {
                    Character->setMD2Animation(scene::EMAT_RUN); 
                    this->bIsRunning = true;
                }
                return true;            
            case irr::KEY_DOWN: 
                Charpos    = Character->getPosition(); 
                Charpos.X = Charpos.X + 10.0f ;
                Character->setPosition(Charpos); 
                Character->setRotation(core::vector3df(0,0,0));
                if (!this->bIsRunning)
                {
                    Character->setMD2Animation(scene::EMAT_RUN); 
                    this->bIsRunning = true;
                }
                return true;
            case irr::KEY_LEFT:  
                Charpos    = Character->getPosition(); 
                Charpos.Z = Charpos.Z - 10.0f ;
                Character->setPosition(Charpos); 
                Character->setRotation(core::vector3df(0,90,0));
                if (!this->bIsRunning)
                {
                    Character->setMD2Animation(scene::EMAT_RUN); 
                    this->bIsRunning = true;
                }
                return true;
            case irr::KEY_RIGHT: 
                Charpos    = Character->getPosition(); 
                Charpos.Z = Charpos.Z + 10.0f ;
                Character->setPosition(Charpos); 
                Character->setRotation(core::vector3df(0,-90,0));
                if (!this->bIsRunning)
                {
                    Character->setMD2Animation(scene::EMAT_RUN); 
                    this->bIsRunning = true;
                }                
                return true;
            case irr::KEY_SPACE:
                if (this->bIsAttacking == 0)
                {
                    Character->setMD2Animation(scene::EMAT_ATTACK); 
                    this->bIsAttacking = 1;    
                }
                return true;
                
                     
            }
        }        
        
        // if one of the walk keys is lifted -> stop run animation
        if (event.EventType == irr::EET_KEY_INPUT_EVENT && !event.KeyInput.PressedDown)
        {
            switch (event.KeyInput.Key)
            {        
            case irr::KEY_UP:
                this->bIsRunning = false;
                Character->setMD2Animation(scene::EMAT_STAND);
                return true;            
            case irr::KEY_DOWN: 
                this->bIsRunning = false;
                Character->setMD2Animation(scene::EMAT_STAND);
                return true;
            case irr::KEY_LEFT:  
                this->bIsRunning = false;
                Character->setMD2Animation(scene::EMAT_STAND);
                return true;
            case irr::KEY_RIGHT: 
                this->bIsRunning = false;
                Character->setMD2Animation(scene::EMAT_STAND);            
                return true;
            case irr::KEY_SPACE:

                return true;
            }
        }
        return false;
    }
private:
    bool bIsRunning;
    int bIsAttacking;
    scene::ISceneNode* Terrain;
    scene::IAnimatedMeshSceneNode* Character;
    IrrlichtDevice* device;


    scene::ICameraSceneNode* pCamera;

    irr::core::vector3df m_lastTargetPos;
    
    irr::core::vector3df Charpos;

    bool m_updated;
    int MouseX;
    float distance;

    float m_yRotationAngle; //the angle about the Y axis 
};


/*
The start of the main function starts like in most other example. We ask the user
for the desired renderer and start it up.
*/
int main()
{
    // let user select driver type

    video::E_DRIVER_TYPE driverType = video::EDT_OPENGL;
    // create device

    IrrlichtDevice* device = createDevice(driverType, core::dimension2d<s32>(1040, 780));

    if (device == 0)
        return 1; // could not create selected driver.

    
    /*
    First, we add standard stuff to the scene: A nice irrlicht engine
    logo, a small help text, a user controlled camera, and we disable
    the mouse cursor.
    */   

    video::IVideoDriver* driver = device->getVideoDriver();
    scene::ISceneManager* smgr = device->getSceneManager();
    gui::IGUIEnvironment* env = device->getGUIEnvironment();

    driver->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT, true);

    //set other font
    env->getSkin()->setFont(env->getFont("../../media/fontlucida.png"));

    // add some help text
    gui::IGUIStaticText* text = env->addStaticText(
        L"Vie : 100/100",
        core::rect<s32>(10,740,250,775), true, true, 0, -1, true);

    // add camera
    scene::ICameraSceneNode* camera = smgr->addCameraSceneNode();

        
    camera->setPosition(core::vector3df(1900*2,255*2,3700*2));
    camera->setTarget(core::vector3df(2397*2,343*2,2700*2));
    camera->setFarValue(12000.0f);

    //mouse cursor
    device->getCursorControl()->setVisible(false);
    smgr->setAmbientLight ( video::SColorf ( 0x00c0c0c0 ) );

    // add terrain scene node
    scene::ITerrainSceneNode* terrain = smgr->addTerrainSceneNode( 
        "../../media/terrain-heightmap2.bmp",
        0,                                        // parent node
        -1,                                        // node id
        core::vector3df(0.f, 0.f, 0.f),            // position
        core::vector3df(0.f, 0.f, 0.f),            // rotation
        core::vector3df(40.f, 4.4f, 40.f),        // scale
        video::SColor ( 255, 255, 255, 255 ),    // vertexColor,
        5,                                        // maxLOD
        scene::ETPS_17,                            // patchSize
        4                                        // smoothFactor
        );

    terrain->setMaterialFlag(video::EMF_LIGHTING, true);

    terrain->setMaterialTexture(0, driver->getTexture("../../media/wall.bmp"));
    terrain->setMaterialTexture(1, driver->getTexture("../../media/Floor09.jpg"));
    
    terrain->setMaterialType(video::EMT_DETAIL_MAP);

    terrain->scaleTexture(1.0f, 40.0f);
    //terrain->setDebugDataVisible ( true );


    /*
    To be able to do collision with the terrain, we create a triangle selector.
    If you want to know what triangle selectors do, just take a look into the 
    collision tutorial. The terrain triangle selector works together with the
    terrain. To demonstrate this, we create a collision response animator 
    and attach it to the camera, so that the camera will not be able to fly 
    through the terrain.
    */

    // create triangle selector for the terrain    
    scene::ITriangleSelector* selector
        = smgr->createTerrainTriangleSelector(terrain, 0);
    terrain->setTriangleSelector(selector);
    selector->drop();




    // create event receiver


// create skybox
    driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, true);

    smgr->addSkyBoxSceneNode(
        driver->getTexture("../../media/irrlicht2_up.jpg"),
        driver->getTexture("../../media/irrlicht2_dn.jpg"),
        driver->getTexture("../../media/irrlicht2_lf.jpg"),
        driver->getTexture("../../media/irrlicht2_rt.jpg"),
        driver->getTexture("../../media/irrlicht2_ft.jpg"),
        driver->getTexture("../../media/irrlicht2_bk.jpg"));

    driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, true);

        smgr->setShadowColor(video::SColor(150,0,255,0));
        scene::IAnimatedMeshSceneNode* Character = smgr->addAnimatedMeshSceneNode(smgr->getMesh("knight.md2"));
        Character->setMaterialFlag(video::EMF_LIGHTING, true);
        Character->setFrameLoop(160, 183);
        Character->setAnimationSpeed(40);
        Character->setMD2Animation(scene::EMAT_STAND);
        Character->setRotation(core::vector3df(0,180.0f,0));
        Character->setMaterialTexture(0, driver->getTexture("knight.bmp"));
        Character->addShadowVolumeSceneNode();
        Character->setPosition(core::vector3df(1900*2,255*2,3700*2));
        scene::ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(
        selector, Character, core::vector3df(60,10,60),
        core::vector3df(0,-100,0), 
        core::vector3df(0,50,0));
        Character->addAnimator(anim);     
        anim->drop();
        
        
        //Iron Golem
        scene::IAnimatedMesh* mesh = smgr->getMesh("Iron_Golem_X.x");
        scene::IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode(mesh);
        node->setMaterialFlag(video::EMF_LIGHTING, true);
        node->setMaterialTexture(0,driver->getTexture("c_golem_iron.tga"));
        node->setPosition(core::vector3df(1900*2, 255*2, 3650*2));
        node->setRotation(core::vector3df(-90,-90,0));
        node->setScale(core::vector3df(0.3,0.3,0.3));
        node->setFrameLoop(200, 260);
        node->setAnimationSpeed(20);
        node->setLoopMode(true);
        node->addShadowVolumeSceneNode();
        scene::ISceneNodeAnimator* anim2 = smgr->createCollisionResponseAnimator(
        selector, node, core::vector3df(60,10,60),
        core::vector3df(0,-100,0), 
        core::vector3df(0,10,0));
        node->addAnimator(anim2);     
        anim2->drop();
        

    MyEventReceiver receiver(terrain,Character,device,camera);
    device->setEventReceiver(&receiver);

    int lastFPS = -1;

        

    while(device->run())
    if (device->isWindowActive())
    {
        driver->beginScene(true, true, 0 );

        receiver.attack();
        smgr->drawAll();
        env->drawAll();

        driver->endScene();

        // display frames per second in window title
        int fps = driver->getFPS();
        if (lastFPS != fps)
        {
            core::stringw str = L"Messiah for all lights - OpenGL [";
            str += driver->getName();
            str += "] FPS:";
            str += fps;
            // Also print terrain height of current camera position
            // We can use camera position because terrain is located at coordinate origin
            str += " Height: ";
            str += terrain->getHeight(camera->getAbsolutePosition().X, camera->getAbsolutePosition().Z);

            device->setWindowCaption(str.c_str());
            lastFPS = fps;
        }
    }

    device->drop();
    
    return 0;
}

MonstreType* Golem = new MonstreType("Golem");
Monstre monstre1;
monstre1.SetType( Golem );

#include ClassPrincipale.h"
#define  blablablabla ....

int main(){  
   
   ClassPrincipale* cp=new cp() ;
   cp->launchgame()


}