Colonization Code

#include <irrlicht.h>
#include <driverChoice.h>

using namespace irr;

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

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

#include <iostream>
using namespace std;

#define _DEBUG_INFO

int error(int errnum, const char errmsg[])
{
    cerr << "ERROR: " << errmsg << " (error ID: " << errnum << ")" << endl;
    return errnum;
}

int warning(int errnum, const char errmsg[])
{
    cerr << "WARNING: " << errmsg << " (error ID: " << errnum << ")" << endl;
    return errnum;
}

void info(const char errmsg[])
{
    cout << "INFO: " << errmsg << endl;
}

void debug(const char errmsg[])
{
     #ifdef _DEBUG_INFO
     cout << "DEBUG: " << errmsg << endl;
     #warning "Debug info enabled! Disable it if you compiling relase version!"
     #endif
}

class MyEventReceiver : public IEventReceiver
{
public:

	MyEventReceiver(scene::ISceneNode* terrain, scene::ISceneNode* skybox, scene::ISceneNode* skydome) :
		Terrain(terrain), Skybox(skybox), Skydome(skydome), showBox(true)
	{
		Skybox->setVisible(true);
		Skydome->setVisible(false);
		
                for (u32 i=0; i<KEY_KEY_CODES_COUNT; ++i)
                        KeyIsDown[i] = false;
	}

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

		return false;
	}
	
        // This is used to check whether a key is being held down
        virtual bool IsKeyDown(EKEY_CODE keyCode) const
        {
                return KeyIsDown[keyCode];
        }

private:
	scene::ISceneNode* Terrain;
	scene::ISceneNode* Skybox;
	scene::ISceneNode* Skydome;
        bool KeyIsDown[KEY_KEY_CODES_COUNT];
	bool showBox;
};

int main()
{
    cout << "Colonization v1.0" << endl << endl;
	video::E_DRIVER_TYPE driverType=driverChoiceConsole();
	if (driverType==video::EDT_COUNT) return error(1, "User not selected driver");
	
	irr::SIrrlichtCreationParameters params;
	params.DriverType=driverType;
	params.WindowSize=core::dimension2d<u32>(800, 600);
	IrrlichtDevice* device = createDeviceEx(params);
	
    if(!device) return error(2, "Failed to create device");
    debug("Device created!");

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

	smgr->loadScene("levels/test.irr");
        
    device->getCursorControl()->setVisible(false);
	
			SKeyMap keyMap[9];
			keyMap[0].Action = EKA_MOVE_FORWARD;
			keyMap[0].KeyCode = KEY_UP;
			keyMap[1].Action = EKA_MOVE_FORWARD;
			keyMap[1].KeyCode = KEY_KEY_W;

			keyMap[2].Action = EKA_MOVE_BACKWARD;
			keyMap[2].KeyCode = KEY_DOWN;
			keyMap[3].Action = EKA_MOVE_BACKWARD;
			keyMap[3].KeyCode = KEY_KEY_S;

			keyMap[4].Action = EKA_STRAFE_LEFT;
			keyMap[4].KeyCode = KEY_LEFT;
			keyMap[5].Action = EKA_STRAFE_LEFT;
			keyMap[5].KeyCode = KEY_KEY_A;

			keyMap[6].Action = EKA_STRAFE_RIGHT;
			keyMap[6].KeyCode = KEY_RIGHT;
			keyMap[7].Action = EKA_STRAFE_RIGHT;
			keyMap[7].KeyCode = KEY_KEY_D;

			keyMap[8].Action = EKA_JUMP_UP;
			keyMap[8].KeyCode = KEY_SPACE;
	
    scene::ICameraSceneNode * camera = smgr->addCameraSceneNodeFPS(0, 50.0f, .1f, -1, keyMap, 9, false, 0.5f);
    scene::IMetaTriangleSelector * meta = smgr->createMetaTriangleSelector();

       core::array<scene::ISceneNode *> nodes;
        smgr->getSceneNodesFromType(scene::ESNT_ANY, nodes); // Find all nodes

        for (u32 i=0; i < nodes.size(); ++i)
        {
                scene::ISceneNode * node = nodes[i];
                scene::ITriangleSelector * selector = 0;

                switch(node->getType())
                {
                case scene::ESNT_CUBE:
                case scene::ESNT_ANIMATED_MESH:
                        // Because the selector won't animate with the mesh,
                        // and is only being used for camera collision, we'll just use an approximate
                        // bounding box instead of ((scene::IAnimatedMeshSceneNode*)node)->getMesh(0)
                        selector = smgr->createTriangleSelectorFromBoundingBox(node);
                break;

                case scene::ESNT_MESH:
                case scene::ESNT_SPHERE: // Derived from IMeshSceneNode
                        selector = smgr->createTriangleSelector(((scene::IMeshSceneNode*)node)->getMesh(), node);
                        break;

                case scene::ESNT_TERRAIN:
                        selector = smgr->createTerrainTriangleSelector((scene::ITerrainSceneNode*)node);
                        break;

                case scene::ESNT_OCTREE:
                        selector = smgr->createOctreeTriangleSelector(((scene::IMeshSceneNode*)node)->getMesh(), node);
                        break;

                default:
                        // Don't create a selector for this node type
                        break;
                }

                if(selector)
                {
                        // Add it to the meta selector, which will take a reference to it
                        meta->addTriangleSelector(selector);
                        // And drop my reference to it, so that the meta selector owns it.
                        selector->drop();
                }
        }
        
        scene::ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(
                meta, camera, core::vector3df(5,5,5),
                core::vector3df(0,-10,0));
        meta->drop(); // I'm done with the meta selector now

        camera->addAnimator(anim);
        anim->drop(); // I'm done with the animator now

        // And set the camera position so that it doesn't start off stuck in the geometry
        camera->setPosition(core::vector3df(0.f, 20.f, 0.f));

        // Point the camera at the cube node, by finding the first node of type ESNT_CUBE
        scene::ISceneNode * cube = smgr->getSceneNodeFromType(scene::ESNT_CUBE);
        if(cube)
                camera->setTarget(cube->getAbsolutePosition());

        int lastFPS = -1;

        while(device->run())
            if (device->isWindowActive())
            {
                    device->getCursorControl()->setVisible(false);
                    driver->beginScene(true, true, video::SColor(0,200,200,200));
                    smgr->drawAll();
                    driver->endScene();
    
                    int fps = driver->getFPS();
    
                    if (lastFPS != fps)
                    {
                            core::stringw str = L"Colonization [";
                            str += driver->getName();
                            str += "] FPS:";
                            str += fps;
    
                            device->setWindowCaption(str.c_str());
                            lastFPS = fps;
                    }
    
            } else device->getCursorControl()->setVisible(true);

        device->drop();

        return 0;
}