#include <irrlicht.h>
#include <iostream>

using namespace irr;

class MyEventReceiver : public IEventReceiver
{
public:
   virtual bool OnEvent(const SEvent& event)
   {
      if (event.EventType == irr::EET_KEY_INPUT_EVENT)
         KeyIsDown[event.KeyInput.Key] = event.KeyInput.PressedDown;

      return false;
   }

   virtual bool IsKeyDown(EKEY_CODE keyCode) const
   {
      return KeyIsDown[keyCode];
   }
   
   MyEventReceiver()
   {
      for (u32 i=0; i<KEY_KEY_CODES_COUNT; ++i)
         KeyIsDown[i] = false;
   }

private:
   bool KeyIsDown[KEY_KEY_CODES_COUNT];
};

using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;

#ifdef _IRR_WINDOWS_
#pragma comment(lib, "Irrlicht.lib")
#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")
#endif

int main()
{
    MyEventReceiver receiver;



   video::E_DRIVER_TYPE driverType;

   printf("Please select the driver you want for this example:\n"\
      " (a) Direct3D 9.0c\n (b) Direct3D 8.1\n (c) OpenGL 1.5\n"\
      " (d) Software Renderer\n (e) Burning's Software Renderer\n"\
      " (f) NullDevice\n (otherKey) exit\n\n");

   char i;
   std::cin >> i;

   switch(i)
   {
      case 'a': driverType = video::EDT_DIRECT3D9;break;
      case 'b': driverType = video::EDT_DIRECT3D8;break;
      case 'c': driverType = video::EDT_OPENGL;   break;
      case 'd': driverType = video::EDT_SOFTWARE; break;
      case 'e': driverType = video::EDT_BURNINGSVIDEO;break;
      case 'f': driverType = video::EDT_NULL;     break;
      default: return 0;
   }
       
    IrrlichtDevice* device = createDevice(driverType, core::dimension2d<s32>(640, 480), 16, false, false, false, &receiver);



   IVideoDriver* driver = device->getVideoDriver();
   ISceneManager* smgr = device->getSceneManager();
   IGUIEnvironment* guienv = device->getGUIEnvironment();



    //Level Map
    device->getFileSystem()->addZipFileArchive("../../media/map-20kdm2.pk3");
   
      scene::IAnimatedMesh* level_mesh = smgr->getMesh("20kdm2.bsp");
   scene::ISceneNode* level_node = 0;
   
   if (level_mesh)
      level_node = smgr->addOctTreeSceneNode(level_mesh->getMesh(0));
      scene::ITriangleSelector* selector = 0;
   
   if (level_node)
   {
      level_node->setPosition(core::vector3df(-1400,-145,-1250));
      selector = smgr->createOctTreeTriangleSelector(level_mesh->getMesh(0), level_node, 128);
      level_node->setTriangleSelector(selector);
   }
   

   
    //Player
   video::SMaterial material;
   material.setTexture(0, driver->getTexture("../../media/faerie2.bmp"));
   material.Lighting = true;
   
   scene::IAnimatedMeshSceneNode* player_node = 0;
   scene::IAnimatedMesh* faerie = smgr->getMesh("../../media/faerie.md2");

   if (faerie)
   {
      player_node = smgr->addAnimatedMeshSceneNode(faerie);
      player_node->getMaterial(0) = material;
      player_node->setPosition(core::vector3df(0,0,50));
      player_node->setScale(core::vector3df(2.f,2.f,2.f));
      player_node->setFrameLoop(0, 0);
      player_node->setAnimationSpeed(15);
                player_node->setMaterialFlag(EMF_LIGHTING, false);
                player_node->setRotation(core::vector3df(0,-90,0));
                player_node->setMD2Animation(scene::EMAT_RUN);
   }
   
   if (selector)
   {
      scene::ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(
         selector, player_node,
            core::vector3df(30,50,30),
         core::vector3df(0,-20,0),
         core::vector3df(0,0,0));
      player_node->addAnimator(anim);
      anim->drop();
   }

   
   
   scene::ICameraSceneNode* camera = smgr->addCameraSceneNodeFPS();
   camera->setPosition(core::vector3df(0,0,0));
   device->getCursorControl()->setVisible(false);
   
   
       
    int lastFPS = -1;
   
    u32 then = device->getTimer()->getTime();
   
    const f32 MOVEMENT_SPEED = 40.f;
   
   
   
   while(device->run())
   {
      const u32 now = device->getTimer()->getTime();
      const f32 frameDeltaTime = (f32)(now - then) / 1000.f;
      then = now;                       
       
                       
      core::vector3df player_nodePosition = player_node->getPosition();
        core::vector3df player_nodeRotation = player_node->getRotation();                 
                       
        if(receiver.IsKeyDown(irr::KEY_KEY_W))
         player_nodePosition.Z += MOVEMENT_SPEED* frameDeltaTime;
      else if(receiver.IsKeyDown(irr::KEY_KEY_S))
         player_nodePosition.Z -= MOVEMENT_SPEED* frameDeltaTime;

      if(receiver.IsKeyDown(irr::KEY_KEY_A))
         player_nodeRotation.Y -= MOVEMENT_SPEED* frameDeltaTime;
      else if(receiver.IsKeyDown(irr::KEY_KEY_D))
         player_nodeRotation.Y += MOVEMENT_SPEED* frameDeltaTime;

      player_node->setPosition(player_nodePosition);
      player_node->setRotation(player_nodeRotation);
       
       
       
        driver->beginScene(true, true, SColor(255,100,101,140));

      smgr->drawAll();
      guienv->drawAll();
      
        driver->endScene();
      
      int fps = driver->getFPS();

        if (lastFPS != fps)
         {
            core::stringw str = L"Irrlicht Engine - Game_by_Shades [";
            str += driver->getName();
            str += "] FPS:";
            str += fps;

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

   device->drop();
   return 0;
}

core::vector3df movementZ(0,0,MOVEMENT_SPEED * frameDeltaTime);
core::vector3df movementY(0,MOVEMENT_SPEED * frameDeltaTime);

core::matrix4 m = player_node->getAbsoluteTransformation();
m.rotateVec( movement );

movement += player_node->getAbsolutePosition();

player_node->setPosition( movement );