New snapshot of dev branch (385-g28b4e9a)

29 files changed, 1233 insertions, 245 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3cb7e70..ed6008a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -98,6 +98,8 @@ option(INSTALL_DOCS "Install Doxygen-generated documentation" OFF)
 # Build openal sound support
 option(OPENAL_SOUND "Build openal sound support" OFF)
 
+# Change to false in case static boost libraries are not available
+option(STATIC_BOOST "Link with static boost libraries" ON)
 
 ##
 # Searching for packages
@@ -110,9 +112,9 @@ find_package(SDL_ttf 2.0 REQUIRED)
 find_package(PNG 1.2 REQUIRED)
 find_package(Gettext REQUIRED)
 
-set(Boost_USE_STATIC_LIBS        ON)
-set(Boost_USE_MULTITHREADED      ON)
-set(Boost_USE_STATIC_RUNTIME    OFF)
+set(Boost_USE_STATIC_LIBS ${STATIC_BOOST})
+set(Boost_USE_MULTITHREADED ON)
+set(Boost_USE_STATIC_RUNTIME OFF)
 
 set(Boost_ADDITIONALVERSION "1.51" "1.51.0")
 find_package(Boost COMPONENTS system filesystem regex REQUIRED)
@@ -184,7 +186,7 @@ endif()
 ##
 # Clipboard support
 ##
-set(CLIPBOARD_DIR ${colobot_SOURCE_DIR}/lib/clipboard/include)
+set(CLIPBOARD_INCLUDE_DIR ${colobot_SOURCE_DIR}/lib/clipboard/include)
 add_subdirectory(${colobot_SOURCE_DIR}/lib/clipboard bin/clipboard)
 
 
diff --git a/debian/changelog b/debian/changelog
index 21873e3..968cb15 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,5 +1,5 @@
-colobot (0.1.0~pre-alpha-git-dev~r376-gb22d852-1~OdyX0) UNRELEASED; urgency=low
+colobot (0.1.0~pre-alpha-git-dev~r385-g28b4e9a-1~OdyX0) UNRELEASED; urgency=low
 
   * Initial release. (Closes: #695829)
 
- -- Didier Raboud <odyx@debian.org>  Sun, 09 Jun 2013 19:01:36 +0200
+ -- Didier Raboud <odyx@debian.org>  Fri, 21 Jun 2013 08:38:38 +0200
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 6318ef2..8493fe8 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -219,7 +219,7 @@ ${GLEW_INCLUDE_PATH}
 ${Boost_INCLUDE_DIRS}
 ${LIBSNDFILE_INCLUDE_DIR}
 ${OPTIONAL_INCLUDE_DIRS}
-${CLIPBOARD_DIR}
+${CLIPBOARD_INCLUDE_DIR}
 )
 
 link_directories(${CMAKE_CURRENT_SOURCE_DIR}/CBot)
diff --git a/src/app/app.cpp b/src/app/app.cpp
index 932e61e..44a7a74 100644
--- a/src/app/app.cpp
+++ b/src/app/app.cpp
@@ -25,13 +25,19 @@
 #include "common/iman.h"
 #include "common/image.h"
 #include "common/key.h"
+#include "common/stringutils.h"
 
 #include "graphics/engine/modelmanager.h"
 #include "graphics/opengl/gldevice.h"
 
 #include "object/robotmain.h"
 
+#ifdef OPENAL_SOUND
+    #include "sound/oalsound/alsound.h"
+#endif
+
 #include <boost/filesystem.hpp>
+#include <boost/tokenizer.hpp>
 
 #include <SDL.h>
 #include <SDL_image.h>
@@ -42,11 +48,6 @@
 #include <getopt.h>
 
 
-#ifdef OPENAL_SOUND
-    #include "sound/oalsound/alsound.h"
-#endif
-
-
 template<> CApplication* CSingleton<CApplication>::m_instance = nullptr;
 
 //! Static buffer for putenv locale
@@ -107,7 +108,7 @@ CApplication::CApplication()
 
     m_exitCode  = 0;
     m_active    = false;
-    m_debugMode = false;
+    m_debugModes = 0;
 
     m_windowTitle = "COLOBOT";
 
@@ -148,10 +149,15 @@ CApplication::CApplication()
     m_langPath = COLOBOT_I18N_DIR;
     m_texPackPath = "";
 
+    m_runSceneName = "";
+    m_runSceneRank = 0;
+
     m_language = LANGUAGE_ENV;
 
     m_lowCPU = true;
 
+    m_protoMode = false;
+
     for (int i = 0; i < DIR_MAX; ++i)
         m_standardDataDirs[i] = nullptr;
 
@@ -216,24 +222,28 @@ ParseArgsStatus CApplication::ParseArguments(int argc, char *argv[])
     {
         OPT_HELP = 1,
         OPT_DEBUG,
-        OPT_DATADIR,
+        OPT_RUNSCENE,
         OPT_LOGLEVEL,
         OPT_LANGUAGE,
+        OPT_DATADIR,
         OPT_LANGDIR,
+        OPT_TEXPACK,
         OPT_VBO,
-        OPT_TEXPACK
+        OPT_PROTO
     };
 
     option options[] =
     {
         { "help", no_argument, nullptr, OPT_HELP },
-        { "debug", no_argument, nullptr, OPT_DEBUG },
-        { "datadir", required_argument, nullptr, OPT_DATADIR },
+        { "debug", required_argument, nullptr, OPT_DEBUG },
+        { "runscene", required_argument, nullptr, OPT_RUNSCENE },
         { "loglevel", required_argument, nullptr, OPT_LOGLEVEL },
         { "language", required_argument, nullptr, OPT_LANGUAGE },
+        { "datadir", required_argument, nullptr, OPT_DATADIR },
         { "langdir", required_argument, nullptr, OPT_LANGDIR },
-        { "vbo", required_argument, nullptr, OPT_VBO },
         { "texpack", required_argument, nullptr, OPT_TEXPACK },
+        { "vbo", required_argument, nullptr, OPT_VBO },
+        { "proto", no_argument, nullptr, OPT_PROTO },
         { nullptr, 0, nullptr, 0}
     };
 
@@ -264,37 +274,44 @@ ParseArgsStatus CApplication::ParseArguments(int argc, char *argv[])
                 GetLogger()->Message("Colobot %s (%s)\n", COLOBOT_CODENAME, COLOBOT_VERSION);
                 GetLogger()->Message("\n");
                 GetLogger()->Message("List of available options:\n");
-                GetLogger()->Message("  -help            this help\n");
-                GetLogger()->Message("  -debug           enable debug mode (more info printed in logs)\n");
-                GetLogger()->Message("  -datadir path    set custom data directory path\n");
-                GetLogger()->Message("  -loglevel level  set log level to level (one of: trace, debug, info, warn, error, none)\n");
-                GetLogger()->Message("  -language lang   set language (one of: en, de, fr, pl)\n");
-                GetLogger()->Message("  -langdir path    set custom language directory path\n");
-                GetLogger()->Message("  -vbo mode        set OpenGL VBO mode (one of: auto, enable, disable)\n");
-                GetLogger()->Message("  -texpack path    set path to custom texture pack\n");
+                GetLogger()->Message("  -help               this help\n");
+                GetLogger()->Message("  -debug modes        enable debug modes (more info printed in logs; see code for reference of modes)\n");
+                GetLogger()->Message("  -runscene sceneNNN  run given scene on start\n");
+                GetLogger()->Message("  -loglevel level     set log level to level (one of: trace, debug, info, warn, error, none)\n");
+                GetLogger()->Message("  -language lang      set language (one of: en, de, fr, pl)\n");
+                GetLogger()->Message("  -datadir path       set custom data directory path\n");
+                GetLogger()->Message("  -langdir path       set custom language directory path\n");
+                GetLogger()->Message("  -texpack path       set path to custom texture pack\n");
+                GetLogger()->Message("  -vbo mode           set OpenGL VBO mode (one of: auto, enable, disable)\n");
+                GetLogger()->Message("  -proto              show prototype levels\n");
                 return PARSE_ARGS_HELP;
             }
             case OPT_DEBUG:
             {
-                SetDebugMode(true);
-                break;
-            }
-            case OPT_DATADIR:
-            {
-                m_dataPath = optarg;
-                GetLogger()->Info("Using custom data dir: '%s'\n", m_dataPath.c_str());
-                break;
-            }
-            case OPT_LANGDIR:
-            {
-                m_langPath = optarg;
-                GetLogger()->Info("Using custom language dir: '%s'\n", m_langPath.c_str());
+                if (optarg == nullptr)
+                {
+                    m_debugModes = DEBUG_ALL;
+                    GetLogger()->Info("All debug modes active\n");
+                }
+                else
+                {
+                    int debugModes;
+                    if (! ParseDebugModes(optarg, debugModes))
+                    {
+                        return PARSE_ARGS_FAIL;
+                    }
+
+                    m_debugModes = debugModes;
+                    GetLogger()->Info("Active debug modes: %s\n", optarg);
+                }
                 break;
             }
-            case OPT_TEXPACK:
+            case OPT_RUNSCENE:
             {
-                m_texPackPath = optarg;
-                GetLogger()->Info("Using texturepack: '%s'\n", m_texPackPath.c_str());
+                std::string file = optarg;
+                m_runSceneName = file.substr(0, file.size()-3);
+                m_runSceneRank = StrUtils::FromString<int>(file.substr(file.size()-3, 3));
+                GetLogger()->Info("Running scene '%s%d' on start\n", m_runSceneName.c_str(), m_runSceneRank);
                 break;
             }
             case OPT_LOGLEVEL:
@@ -302,7 +319,7 @@ ParseArgsStatus CApplication::ParseArguments(int argc, char *argv[])
                 LogLevel logLevel;
                 if (! CLogger::ParseLogLevel(optarg, logLevel))
                 {
-                    GetLogger()->Error("Invalid log level: \"%s\"\n", optarg);
+                    GetLogger()->Error("Invalid log level: '%s'\n", optarg);
                     return PARSE_ARGS_FAIL;
                 }
 
@@ -315,7 +332,7 @@ ParseArgsStatus CApplication::ParseArguments(int argc, char *argv[])
                 Language language;
                 if (! ParseLanguage(optarg, language))
                 {
-                    GetLogger()->Error("Invalid language: \"%s\"\n", optarg);
+                    GetLogger()->Error("Invalid language: '%s'\n", optarg);
                     return PARSE_ARGS_FAIL;
                 }
 
@@ -323,6 +340,24 @@ ParseArgsStatus CApplication::ParseArguments(int argc, char *argv[])
                 m_language = language;
                 break;
             }
+            case OPT_DATADIR:
+            {
+                m_dataPath = optarg;
+                GetLogger()->Info("Using custom data dir: '%s'\n", m_dataPath.c_str());
+                break;
+            }
+            case OPT_LANGDIR:
+            {
+                m_langPath = optarg;
+                GetLogger()->Info("Using custom language dir: '%s'\n", m_langPath.c_str());
+                break;
+            }
+            case OPT_TEXPACK:
+            {
+                m_texPackPath = optarg;
+                GetLogger()->Info("Using texturepack: '%s'\n", m_texPackPath.c_str());
+                break;
+            }
             case OPT_VBO:
             {
                 std::string vbo;
@@ -335,12 +370,17 @@ ParseArgsStatus CApplication::ParseArguments(int argc, char *argv[])
                     m_deviceConfig.vboMode = Gfx::VBO_MODE_DISABLE;
                 else
                 {
-                    GetLogger()->Error("Invalid vbo mode: \"%s\"\n", optarg);
+                    GetLogger()->Error("Invalid vbo mode: '%s'\n", optarg);
                     return PARSE_ARGS_FAIL;
                 }
 
                 break;
             }
+            case OPT_PROTO:
+            {
+                m_protoMode = true;
+                break;
+            }
             default:
                 assert(false); // should never get here
         }
@@ -517,7 +557,10 @@ bool CApplication::Create()
 
     if (defaultValues) m_robotMain->CreateIni();
 
-    m_robotMain->ChangePhase(PHASE_WELCOME1);
+    if (! m_runSceneName.empty())
+        m_robotMain->LoadSceneOnStart(m_runSceneName, m_runSceneRank);
+    else
+        m_robotMain->ChangePhase(PHASE_WELCOME1);
 
     return true;
 }
@@ -641,7 +684,7 @@ bool CApplication::ChangeVideoConfig(const Gfx::GLDeviceConfig &newConfig)
     if (! CreateVideoSurface())
     {
         // Fatal error, so post the quit event
-        m_eventQueue->AddEvent(Event(EVENT_QUIT));
+        m_eventQueue->AddEvent(Event(EVENT_SYS_QUIT));
         return false;
     }
 
@@ -670,7 +713,7 @@ bool CApplication::ChangeVideoConfig(const Gfx::GLDeviceConfig &newConfig)
 
 
             // Fatal error, so post the quit event
-            m_eventQueue->AddEvent(Event(EVENT_QUIT));
+            m_eventQueue->AddEvent(Event(EVENT_SYS_QUIT));
             return false;
         }
     }
@@ -854,31 +897,15 @@ int CApplication::Run()
 
                 Event event = ProcessSystemEvent();
 
-                if (event.type == EVENT_QUIT)
+                if (event.type == EVENT_SYS_QUIT)
                     goto end; // exit the loop
 
                 if (event.type != EVENT_NULL)
-                {
-                    bool passOn = ProcessEvent(event);
-
-                    if (m_engine != nullptr && passOn)
-                        passOn = m_engine->ProcessEvent(event);
-
-                    if (passOn)
-                        m_eventQueue->AddEvent(event);
-                }
+                    m_eventQueue->AddEvent(event);
 
                 Event virtualEvent = CreateVirtualEvent(event);
                 if (virtualEvent.type != EVENT_NULL)
-                {
-                    bool passOn = ProcessEvent(virtualEvent);
-
-                    if (m_engine != nullptr && passOn)
-                        passOn = m_engine->ProcessEvent(virtualEvent);
-
-                    if (passOn)
-                        m_eventQueue->AddEvent(virtualEvent);
-                }
+                    m_eventQueue->AddEvent(virtualEvent);
             }
         }
 
@@ -889,19 +916,11 @@ int CApplication::Run()
 
             Event event = ProcessSystemEvent();
 
-            if (event.type == EVENT_QUIT)
+            if (event.type == EVENT_SYS_QUIT)
                 goto end; // exit the loop
 
             if (event.type != EVENT_NULL)
-            {
-                bool passOn = ProcessEvent(event);
-
-                if (m_engine != nullptr && passOn)
-                    passOn = m_engine->ProcessEvent(event);
-
-                if (passOn)
-                    m_eventQueue->AddEvent(event);
-            }
+                m_eventQueue->AddEvent(event);
         }
 
         // Enter game update & frame rendering only if active
@@ -910,22 +929,17 @@ int CApplication::Run()
             Event event;
             while (m_eventQueue->GetEvent(event))
             {
-                if (event.type == EVENT_QUIT)
+                if (event.type == EVENT_SYS_QUIT || event.type == EVENT_QUIT)
                     goto end; // exit both loops
 
-                bool passOn = true;
+                LogEvent(event);
 
-                // Skip system events (they have been processed earlier)
-                if (! event.systemEvent)
-                {
-                    passOn = ProcessEvent(event);
-
-                    if (passOn && m_engine != nullptr)
-                        passOn = m_engine->ProcessEvent(event);
-                }
+                bool passOn = true;
+                if (m_engine != nullptr)
+                    passOn = m_engine->ProcessEvent(event);
 
                 if (passOn && m_robotMain != nullptr)
-                    m_robotMain->EventProcess(event);
+                    m_robotMain->ProcessEvent(event);
             }
 
             StopPerformanceCounter(PCNT_EVENT_PROCESSING);
@@ -936,6 +950,8 @@ int CApplication::Run()
             event = CreateUpdateEvent();
             if (event.type != EVENT_NULL && m_robotMain != nullptr)
             {
+                LogEvent(event);
+
                 StartPerformanceCounter(PCNT_UPDATE_ENGINE);
                 m_engine->FrameUpdate();
                 StopPerformanceCounter(PCNT_UPDATE_ENGINE);
@@ -943,7 +959,7 @@ int CApplication::Run()
                 m_sound->FrameMove(m_relTime);
 
                 StartPerformanceCounter(PCNT_UPDATE_GAME);
-                m_robotMain->EventProcess(event);
+                m_robotMain->ProcessEvent(event);
                 StopPerformanceCounter(PCNT_UPDATE_GAME);
             }
 
@@ -989,11 +1005,10 @@ const std::string& CApplication::GetErrorMessage() const
 Event CApplication::ProcessSystemEvent()
 {
     Event event;
-    event.systemEvent = true;
 
     if (m_private->currentEvent.type == SDL_QUIT)
     {
-        event.type = EVENT_QUIT;
+        event.type = EVENT_SYS_QUIT;
     }
     else if (m_private->currentEvent.type == SDL_VIDEORESIZE)
     {
@@ -1139,76 +1154,74 @@ Event CApplication::ProcessSystemEvent()
     return event;
 }
 
-/**
- * Processes incoming events. It is the first function called after an event is captured.
- * Event is modified, updating its tracked keys state and mouse position to current values.
- * Function returns \c true if the event is to be passed on to other processing functions
- * or \c false if not. */
-bool CApplication::ProcessEvent(const Event &event)
+void CApplication::LogEvent(const Event &event)
 {
     CLogger *l = GetLogger();
 
-    // Print the events in debug mode to test the code
-    if (m_debugMode)
+    auto PrintEventDetails = [&]()
     {
-        switch (event.type)
-        {
-            case EVENT_KEY_DOWN:
-            case EVENT_KEY_UP:
-                l->Trace("EVENT_KEY_%s:\n", (event.type == EVENT_KEY_DOWN) ? "DOWN" : "UP");
-                l->Trace(" virt    = %s\n", (event.key.virt) ? "true" : "false");
-                l->Trace(" key     = %d\n", event.key.key);
-                l->Trace(" unicode = 0x%04x\n", event.key.unicode);
-                break;
-            case EVENT_MOUSE_MOVE:
-                l->Trace("EVENT_MOUSE_MOVE:\n");
-                break;
-            case EVENT_MOUSE_BUTTON_DOWN:
-            case EVENT_MOUSE_BUTTON_UP:
-                l->Trace("EVENT_MOUSE_BUTTON_%s:\n", (event.type == EVENT_MOUSE_BUTTON_DOWN) ? "DOWN" : "UP");
-                l->Trace(" button = %d\n", event.mouseButton.button);
-                break;
-            case EVENT_MOUSE_WHEEL:
-                l->Trace("EVENT_MOUSE_WHEEL:\n");
-                l->Trace(" dir = %s\n", (event.mouseWheel.dir == WHEEL_DOWN) ? "WHEEL_DOWN" : "WHEEL_UP");
-               break;
-            case EVENT_JOY_AXIS:
-                l->Trace("EVENT_JOY_AXIS:\n");
-                l->Trace(" axis  = %d\n", event.joyAxis.axis);
-                l->Trace(" value = %d\n", event.joyAxis.value);
-                break;
-            case EVENT_JOY_BUTTON_DOWN:
-            case EVENT_JOY_BUTTON_UP:
-                l->Trace("EVENT_JOY_BUTTON_%s:\n", (event.type == EVENT_JOY_BUTTON_DOWN) ? "DOWN" : "UP");
-                l->Trace(" button = %d\n", event.joyButton.button);
-                break;
-            case EVENT_ACTIVE:
-                l->Trace("EVENT_ACTIVE:\n");
-                l->Trace(" flags = 0x%x\n", event.active.flags);
-                l->Trace(" gain  = %s\n", event.active.gain ? "true" : "false");
-                break;
-            default:
-                l->Trace("Event type = %d:\n", static_cast<int>(event.type));
-                break;
-        }
-
-        l->Trace(" systemEvent = %s\n", event.systemEvent ? "true" : "false");
         l->Trace(" rTime = %f\n", event.rTime);
         l->Trace(" kmodState = %04x\n", event.kmodState);
         l->Trace(" trackedKeysState = %04x\n", event.trackedKeysState);
         l->Trace(" mousePos = %f, %f\n", event.mousePos.x, event.mousePos.y);
         l->Trace(" mouseButtonsState = %02x\n", event.mouseButtonsState);
-    }
+        l->Trace(" customParam = %d\n", event.customParam);
+    };
 
-    // By default, pass on all events
-    return true;
+    // Print the events in debug mode to test the code
+    if (IsDebugModeActive(DEBUG_SYS_EVENTS) || IsDebugModeActive(DEBUG_APP_EVENTS))
+    {
+        std::string eventType = ParseEventType(event.type);
+
+        if (IsDebugModeActive(DEBUG_SYS_EVENTS) && event.type <= EVENT_SYS_MAX)
+        {
+            l->Trace("System event %s:\n", eventType.c_str());
+            switch (event.type)
+            {
+                case EVENT_KEY_DOWN:
+                case EVENT_KEY_UP:
+                    l->Trace(" virt    = %s\n", (event.key.virt) ? "true" : "false");
+                    l->Trace(" key     = %d\n", event.key.key);
+                    l->Trace(" unicode = 0x%04x\n", event.key.unicode);
+                    break;
+                case EVENT_MOUSE_BUTTON_DOWN:
+                case EVENT_MOUSE_BUTTON_UP:
+                    l->Trace(" button = %d\n", event.mouseButton.button);
+                    break;
+                case EVENT_MOUSE_WHEEL:
+                    l->Trace(" dir = %s\n", (event.mouseWheel.dir == WHEEL_DOWN) ? "WHEEL_DOWN" : "WHEEL_UP");
+                break;
+                case EVENT_JOY_AXIS:
+                    l->Trace(" axis  = %d\n", event.joyAxis.axis);
+                    l->Trace(" value = %d\n", event.joyAxis.value);
+                    break;
+                case EVENT_JOY_BUTTON_DOWN:
+                case EVENT_JOY_BUTTON_UP:
+                    l->Trace(" button = %d\n", event.joyButton.button);
+                    break;
+                case EVENT_ACTIVE:
+                    l->Trace(" flags = 0x%x\n", event.active.flags);
+                    l->Trace(" gain  = %s\n", event.active.gain ? "true" : "false");
+                    break;
+                default:
+                    break;
+            }
+
+            PrintEventDetails();
+        }
+
+        if (IsDebugModeActive(DEBUG_APP_EVENTS) && event.type > EVENT_SYS_MAX)
+        {
+            l->Trace("App event %s:\n", eventType.c_str());
+            PrintEventDetails();
+        }
+    }
 }
 
 
 Event CApplication::CreateVirtualEvent(const Event& sourceEvent)
 {
     Event virtualEvent;
-    virtualEvent.systemEvent = true;
 
     if ((sourceEvent.type == EVENT_KEY_DOWN) || (sourceEvent.type == EVENT_KEY_UP))
     {
@@ -1264,13 +1277,24 @@ void CApplication::SuspendSimulation()
 void CApplication::ResumeSimulation()
 {
     m_simulationSuspended = false;
+    InternalResumeSimulation();
 
+    GetLogger()->Info("Resume simulation\n");
+}
+
+void CApplication::ResetTimeAfterLoading()
+{
+    InternalResumeSimulation();
+
+    GetLogger()->Trace("Resume simulation on loading\n");
+}
+
+void CApplication::InternalResumeSimulation()
+{
     GetSystemUtils()->GetCurrentTimeStamp(m_baseTimeStamp);
     GetSystemUtils()->CopyTimeStamp(m_curTimeStamp, m_baseTimeStamp);
     m_realAbsTimeBase = m_realAbsTime;
     m_absTimeBase = m_exactAbsTime;
-
-    GetLogger()->Info("Resume simulation\n");
 }
 
 bool CApplication::GetSimulationSuspended() const
@@ -1305,7 +1329,7 @@ Event CApplication::CreateUpdateEvent()
     {
         GetLogger()->Error("Fatal error: got negative system counter difference!\n");
         GetLogger()->Error("This should never happen. Please report this error.\n");
-        m_eventQueue->AddEvent(Event(EVENT_QUIT));
+        m_eventQueue->AddEvent(Event(EVENT_SYS_QUIT));
         return Event(EVENT_NULL);
     }
     else
@@ -1321,7 +1345,6 @@ Event CApplication::CreateUpdateEvent()
     }
 
     Event frameEvent(EVENT_FRAME);
-    frameEvent.systemEvent = true;
     frameEvent.trackedKeysState = m_trackedKeys;
     frameEvent.kmodState = m_kmodState;
     frameEvent.mousePos = m_mousePos;
@@ -1414,14 +1437,55 @@ VideoQueryResult CApplication::GetVideoResolutionList(std::vector<Math::IntPoint
     return VIDEO_QUERY_OK;
 }
 
-void CApplication::SetDebugMode(bool mode)
+void CApplication::SetDebugModeActive(DebugMode mode, bool active)
+{
+    if (active)
+        m_debugModes |= mode;
+    else
+        m_debugModes &= (~mode);
+}
+
+bool CApplication::IsDebugModeActive(DebugMode mode) const
 {
-    m_debugMode = mode;
+    return (m_debugModes & mode) != 0;
 }
 
-bool CApplication::GetDebugMode() const
+bool CApplication::ParseDebugModes(const std::string& str, int& debugModes)
 {
-    return m_debugMode;
+    debugModes = 0;
+
+    boost::char_separator<char> sep(",");
+    boost::tokenizer<boost::char_separator<char>> tokens(str, sep);
+    for (const auto& modeToken : tokens)
+    {
+        if (modeToken == "sys_events")
+        {
+            debugModes |= DEBUG_SYS_EVENTS;
+        }
+        else if (modeToken == "app_events")
+        {
+            debugModes |= DEBUG_APP_EVENTS;
+        }
+        else if (modeToken == "events")
+        {
+            debugModes |= DEBUG_EVENTS;
+        }
+        else if (modeToken == "models")
+        {
+            debugModes |= DEBUG_MODELS;
+        }
+        else if (modeToken == "all")
+        {
+            debugModes = DEBUG_ALL;
+        }
+        else
+        {
+            GetLogger()->Error("Invalid debug mode: '%s'\n", modeToken.c_str());
+            return false;
+        }
+    }
+
+    return true;
 }
 
 int CApplication::GetKmods() const
@@ -1771,3 +1835,8 @@ void CApplication::UpdatePerformanceCountersData()
     }
 }
 
+bool CApplication::GetProtoMode() const
+{
+    return m_protoMode;
+}
+
diff --git a/src/app/app.h b/src/app/app.h
index 34028c7..269fa9b 100644
--- a/src/app/app.h
+++ b/src/app/app.h
@@ -143,6 +143,15 @@ enum PerformanceCounter
     PCNT_MAX
 };
 
+enum DebugMode
+{
+    DEBUG_SYS_EVENTS = 1 << 0,
+    DEBUG_APP_EVENTS = 1 << 1,
+    DEBUG_EVENTS     = DEBUG_SYS_EVENTS | DEBUG_APP_EVENTS,
+    DEBUG_MODELS     = 1 << 2,
+    DEBUG_ALL        = DEBUG_SYS_EVENTS | DEBUG_APP_EVENTS | DEBUG_MODELS
+};
+
 struct ApplicationPrivate;
 
 /**
@@ -234,6 +243,9 @@ public:
     //! Returns whether simulation is suspended
     bool        GetSimulationSuspended() const;
 
+    //! Resets time counters to account for time spent loading game
+    void        ResetTimeAfterLoading();
+
     //@{
     //! Management of simulation speed
     void            SetSimulationSpeed(float speed);
@@ -309,10 +321,11 @@ public:
     //! Moves (warps) the mouse cursor to the specified position (in interface coords)
     void        MoveMouse(Math::Point pos);
 
-    //! Management of debug mode (prints more info in logger)
+    //! Management of debug modes (printing more info in logger)
     //@{
-    void        SetDebugMode(bool mode);
-    bool        GetDebugMode() const;
+    void        SetDebugModeActive(DebugMode mode, bool active);
+    bool        IsDebugModeActive(DebugMode mode) const;
+    static bool ParseDebugModes(const std::string& str, int& debugModes);
     //@}
 
     //! Returns the full path to data directory
@@ -348,6 +361,8 @@ public:
     float       GetPerformanceCounterData(PerformanceCounter counter) const;
     //@}
 
+    bool        GetProtoMode() const;
+
 protected:
     //! Creates the window's SDL_Surface
     bool CreateVideoSurface();
@@ -358,8 +373,8 @@ protected:
     Event       CreateVirtualEvent(const Event& sourceEvent);
     //! Prepares a simulation update event
     TEST_VIRTUAL Event CreateUpdateEvent();
-    //! Handles some incoming events
-    bool        ProcessEvent(const Event& event);
+    //! Logs debug data for event
+    void        LogEvent(const Event& event);
     //! Renders the image in window
     void        Render();
 
@@ -368,6 +383,9 @@ protected:
     //! Closes the joystick device
     void CloseJoystick();
 
+    //! Internal procedure to reset time counters
+    void InternalResumeSimulation();
+
     //! Resets all performance counters to zero
     void ResetPerformanceCounters();
     //! Updates performance counters from gathered timer data
@@ -400,8 +418,8 @@ protected:
     int             m_exitCode;
     //! Whether application window is active
     bool            m_active;
-    //! Whether debug mode is enabled
-    bool            m_debugMode;
+    //! Bit array of active debug modes
+    long            m_debugModes;
 
     //! Message to be displayed as error to the user
     std::string     m_errorMessage;
@@ -468,6 +486,12 @@ protected:
     //! Path to directory with user texture pack
     std::string     m_texPackPath;
 
+    //@{
+    //! Scene to run on startup
+    std::string     m_runSceneName;
+    int             m_runSceneRank;
+    //@}
+
     const char*     m_standardDataDirs[DIR_MAX];
 
     //! Application language
@@ -475,5 +499,8 @@ protected:
 
     //! Low cpu mode
     bool            m_lowCPU;
+
+    //! Show prototype levels
+    bool            m_protoMode;
 };
 
diff --git a/src/app/main.cpp b/src/app/main.cpp
index 4bd5daa..5c0afd3 100644
--- a/src/app/main.cpp
+++ b/src/app/main.cpp
@@ -78,7 +78,9 @@ int SDL_MAIN_FUNC(int argc, char *argv[])
 {
     CLogger logger; // single istance of logger
 
-    InitializeRestext(); // init static translation strings
+    // Initialize static string arrays
+    InitializeRestext();
+    InitializeEventTypeTexts();
 
     CSystemUtils* systemUtils = CSystemUtils::Create(); // platform-specific utils
     systemUtils->Init();
diff --git a/src/common/event.cpp b/src/common/event.cpp
index ff3fbc7..7acac77 100644
--- a/src/common/event.cpp
+++ b/src/common/event.cpp
@@ -19,15 +19,541 @@
 
 #include "common/logger.h"
 
-static EventType g_uniqueEventType = EVENT_USER;
+namespace
+{
+static EventType UNIQUE_EVENT_TYPE = EVENT_USER;
+const char* EVENT_TYPE_TEXT[EVENT_STD_MAX];
+}
 
+EventType GetUniqueEventType()
+{
+    int i = static_cast<int>(UNIQUE_EVENT_TYPE+1);
+    UNIQUE_EVENT_TYPE = static_cast<EventType>(i);
+    return UNIQUE_EVENT_TYPE;
+}
 
+void InitializeEventTypeTexts()
+{
+    for (int i = 0; i < EVENT_STD_MAX; ++i)
+        EVENT_TYPE_TEXT[i] = "";
 
-EventType GetUniqueEventType()
+    EVENT_TYPE_TEXT[EVENT_NULL]              = "EVENT_NULL";
+
+    EVENT_TYPE_TEXT[EVENT_QUIT]              = "EVENT_QUIT";
+
+    EVENT_TYPE_TEXT[EVENT_FRAME]             = "EVENT_FRAME";
+
+    EVENT_TYPE_TEXT[EVENT_MOUSE_BUTTON_DOWN] = "EVENT_MOUSE_BUTTON_DOWN";
+    EVENT_TYPE_TEXT[EVENT_MOUSE_BUTTON_UP]   = "EVENT_MOUSE_BUTTON_UP";
+    EVENT_TYPE_TEXT[EVENT_MOUSE_WHEEL]       = "EVENT_MOUSE_WHEEL";
+    EVENT_TYPE_TEXT[EVENT_MOUSE_MOVE]        = "EVENT_MOUSE_MOVE";
+    EVENT_TYPE_TEXT[EVENT_KEY_DOWN]          = "EVENT_KEY_DOWN";
+    EVENT_TYPE_TEXT[EVENT_KEY_UP]            = "EVENT_KEY_UP";
+
+    EVENT_TYPE_TEXT[EVENT_ACTIVE]            = "EVENT_ACTIVE";
+
+    EVENT_TYPE_TEXT[EVENT_JOY_AXIS]          = "EVENT_JOY_AXIS";
+    EVENT_TYPE_TEXT[EVENT_JOY_BUTTON_DOWN]   = "EVENT_JOY_BUTTON_DOWN";
+    EVENT_TYPE_TEXT[EVENT_JOY_BUTTON_UP]     = "EVENT_JOY_BUTTON_UP";
+
+
+    EVENT_TYPE_TEXT[EVENT_UPDINTERFACE]      = "EVENT_UPDINTERFACE";
+    EVENT_TYPE_TEXT[EVENT_WIN]               = "EVENT_WIN";
+    EVENT_TYPE_TEXT[EVENT_LOST]              = "EVENT_LOST";
+
+    EVENT_TYPE_TEXT[EVENT_FOCUS]             = "EVENT_FOCUS";
+
+    EVENT_TYPE_TEXT[EVENT_BUTTON_OK]         = "EVENT_BUTTON_OK";
+    EVENT_TYPE_TEXT[EVENT_BUTTON_CANCEL]     = "EVENT_BUTTON_CANCEL";
+    EVENT_TYPE_TEXT[EVENT_BUTTON_NEXT]       = "EVENT_BUTTON_NEXT";
+    EVENT_TYPE_TEXT[EVENT_BUTTON_PREV]       = "EVENT_BUTTON_PREV";
+    EVENT_TYPE_TEXT[EVENT_BUTTON_QUIT]       = "EVENT_BUTTON_QUIT";
+
+    EVENT_TYPE_TEXT[EVENT_BUTTON0]           = "EVENT_BUTTON0";
+    EVENT_TYPE_TEXT[EVENT_BUTTON1]           = "EVENT_BUTTON1";
+    EVENT_TYPE_TEXT[EVENT_BUTTON2]           = "EVENT_BUTTON2";
+    EVENT_TYPE_TEXT[EVENT_BUTTON3]           = "EVENT_BUTTON3";
+    EVENT_TYPE_TEXT[EVENT_BUTTON4]           = "EVENT_BUTTON4";
+    EVENT_TYPE_TEXT[EVENT_BUTTON5]           = "EVENT_BUTTON5";
+    EVENT_TYPE_TEXT[EVENT_BUTTON6]           = "EVENT_BUTTON6";
+    EVENT_TYPE_TEXT[EVENT_BUTTON7]           = "EVENT_BUTTON7";
+    EVENT_TYPE_TEXT[EVENT_BUTTON8]           = "EVENT_BUTTON8";
+    EVENT_TYPE_TEXT[EVENT_BUTTON9]           = "EVENT_BUTTON9";
+    EVENT_TYPE_TEXT[EVENT_BUTTON10]          = "EVENT_BUTTON10";
+    EVENT_TYPE_TEXT[EVENT_BUTTON11]          = "EVENT_BUTTON11";
+    EVENT_TYPE_TEXT[EVENT_BUTTON12]          = "EVENT_BUTTON12";
+    EVENT_TYPE_TEXT[EVENT_BUTTON13]          = "EVENT_BUTTON13";
+    EVENT_TYPE_TEXT[EVENT_BUTTON14]          = "EVENT_BUTTON14";
+    EVENT_TYPE_TEXT[EVENT_BUTTON15]          = "EVENT_BUTTON15";
+    EVENT_TYPE_TEXT[EVENT_BUTTON16]          = "EVENT_BUTTON16";
+    EVENT_TYPE_TEXT[EVENT_BUTTON17]          = "EVENT_BUTTON17";
+    EVENT_TYPE_TEXT[EVENT_BUTTON18]          = "EVENT_BUTTON18";
+    EVENT_TYPE_TEXT[EVENT_BUTTON19]          = "EVENT_BUTTON19";
+
+    EVENT_TYPE_TEXT[EVENT_EDIT0]             = "EVENT_EDIT0";
+    EVENT_TYPE_TEXT[EVENT_EDIT1]             = "EVENT_EDIT1";
+    EVENT_TYPE_TEXT[EVENT_EDIT2]             = "EVENT_EDIT2";
+    EVENT_TYPE_TEXT[EVENT_EDIT3]             = "EVENT_EDIT3";
+    EVENT_TYPE_TEXT[EVENT_EDIT4]             = "EVENT_EDIT4";
+    EVENT_TYPE_TEXT[EVENT_EDIT5]             = "EVENT_EDIT5";
+    EVENT_TYPE_TEXT[EVENT_EDIT6]             = "EVENT_EDIT6";
+    EVENT_TYPE_TEXT[EVENT_EDIT7]             = "EVENT_EDIT7";
+    EVENT_TYPE_TEXT[EVENT_EDIT8]             = "EVENT_EDIT8";
+    EVENT_TYPE_TEXT[EVENT_EDIT9]             = "EVENT_EDIT9";
+
+    EVENT_TYPE_TEXT[EVENT_WINDOW0]           = "EVENT_WINDOW0";
+    EVENT_TYPE_TEXT[EVENT_WINDOW1]           = "EVENT_WINDOW1";
+    EVENT_TYPE_TEXT[EVENT_WINDOW2]           = "EVENT_WINDOW2";
+    EVENT_TYPE_TEXT[EVENT_WINDOW3]           = "EVENT_WINDOW3";
+    EVENT_TYPE_TEXT[EVENT_WINDOW4]           = "EVENT_WINDOW4";
+    EVENT_TYPE_TEXT[EVENT_WINDOW5]           = "EVENT_WINDOW5";
+    EVENT_TYPE_TEXT[EVENT_WINDOW6]           = "EVENT_WINDOW6";
+    EVENT_TYPE_TEXT[EVENT_WINDOW7]           = "EVENT_WINDOW7";
+    EVENT_TYPE_TEXT[EVENT_WINDOW8]           = "EVENT_WINDOW8";
+    EVENT_TYPE_TEXT[EVENT_WINDOW9]           = "EVENT_WINDOW9";
+
+    EVENT_TYPE_TEXT[EVENT_LABEL0]            = "EVENT_LABEL0";
+    EVENT_TYPE_TEXT[EVENT_LABEL1]            = "EVENT_LABEL1";
+    EVENT_TYPE_TEXT[EVENT_LABEL2]            = "EVENT_LABEL2";
+    EVENT_TYPE_TEXT[EVENT_LABEL3]            = "EVENT_LABEL3";
+    EVENT_TYPE_TEXT[EVENT_LABEL4]            = "EVENT_LABEL4";
+    EVENT_TYPE_TEXT[EVENT_LABEL5]            = "EVENT_LABEL5";
+    EVENT_TYPE_TEXT[EVENT_LABEL6]            = "EVENT_LABEL6";
+    EVENT_TYPE_TEXT[EVENT_LABEL7]            = "EVENT_LABEL7";
+    EVENT_TYPE_TEXT[EVENT_LABEL8]            = "EVENT_LABEL8";
+    EVENT_TYPE_TEXT[EVENT_LABEL9]            = "EVENT_LABEL9";
+    EVENT_TYPE_TEXT[EVENT_LABEL10]           = "EVENT_LABEL10";
+    EVENT_TYPE_TEXT[EVENT_LABEL11]           = "EVENT_LABEL11";
+    EVENT_TYPE_TEXT[EVENT_LABEL12]           = "EVENT_LABEL12";
+    EVENT_TYPE_TEXT[EVENT_LABEL13]           = "EVENT_LABEL13";
+    EVENT_TYPE_TEXT[EVENT_LABEL14]           = "EVENT_LABEL14";
+    EVENT_TYPE_TEXT[EVENT_LABEL15]           = "EVENT_LABEL15";
+    EVENT_TYPE_TEXT[EVENT_LABEL16]           = "EVENT_LABEL16";
+    EVENT_TYPE_TEXT[EVENT_LABEL17]           = "EVENT_LABEL17";
+    EVENT_TYPE_TEXT[EVENT_LABEL18]           = "EVENT_LABEL18";
+    EVENT_TYPE_TEXT[EVENT_LABEL19]           = "EVENT_LABEL19";
+
+    EVENT_TYPE_TEXT[EVENT_LIST0]             = "EVENT_LIST0";
+    EVENT_TYPE_TEXT[EVENT_LIST1]             = "EVENT_LIST1";
+    EVENT_TYPE_TEXT[EVENT_LIST2]             = "EVENT_LIST2";
+    EVENT_TYPE_TEXT[EVENT_LIST3]             = "EVENT_LIST3";
+    EVENT_TYPE_TEXT[EVENT_LIST4]             = "EVENT_LIST4";
+    EVENT_TYPE_TEXT[EVENT_LIST5]             = "EVENT_LIST5";
+    EVENT_TYPE_TEXT[EVENT_LIST6]             = "EVENT_LIST6";
+    EVENT_TYPE_TEXT[EVENT_LIST7]             = "EVENT_LIST7";
+    EVENT_TYPE_TEXT[EVENT_LIST8]             = "EVENT_LIST8";
+    EVENT_TYPE_TEXT[EVENT_LIST9]             = "EVENT_LIST9";
+
+    EVENT_TYPE_TEXT[EVENT_TOOLTIP]           = "EVENT_TOOLTIP";
+
+    EVENT_TYPE_TEXT[EVENT_DIALOG_OK]         = "EVENT_DIALOG_OK";
+    EVENT_TYPE_TEXT[EVENT_DIALOG_CANCEL]     = "EVENT_DIALOG_CANCEL";
+    EVENT_TYPE_TEXT[EVENT_DIALOG_LABEL]      = "EVENT_DIALOG_LABEL";
+    EVENT_TYPE_TEXT[EVENT_DIALOG_LABEL1]     = "EVENT_DIALOG_LABEL1";
+    EVENT_TYPE_TEXT[EVENT_DIALOG_LABEL2]     = "EVENT_DIALOG_LABEL2";
+    EVENT_TYPE_TEXT[EVENT_DIALOG_LABEL3]     = "EVENT_DIALOG_LABEL3";
+    EVENT_TYPE_TEXT[EVENT_DIALOG_LIST]       = "EVENT_DIALOG_LIST";
+    EVENT_TYPE_TEXT[EVENT_DIALOG_EDIT]       = "EVENT_DIALOG_EDIT";
+    EVENT_TYPE_TEXT[EVENT_DIALOG_CHECK1]     = "EVENT_DIALOG_CHECK1";
+    EVENT_TYPE_TEXT[EVENT_DIALOG_CHECK2]     = "EVENT_DIALOG_CHECK2";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_TRAINER] = "EVENT_INTERFACE_TRAINER";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_DEFI]    = "EVENT_INTERFACE_DEFI";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_MISSION] = "EVENT_INTERFACE_MISSION";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_FREE]    = "EVENT_INTERFACE_FREE";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PROTO]   = "EVENT_INTERFACE_PROTO";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_NAME]    = "EVENT_INTERFACE_NAME";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_SETUP]   = "EVENT_INTERFACE_SETUP";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_QUIT]    = "EVENT_INTERFACE_QUIT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_BACK]    = "EVENT_INTERFACE_BACK";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_AGAIN]   = "EVENT_INTERFACE_AGAIN";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_WRITE]   = "EVENT_INTERFACE_WRITE";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_READ]    = "EVENT_INTERFACE_READ";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_ABORT]   = "EVENT_INTERFACE_ABORT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_USER]    = "EVENT_INTERFACE_USER";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_TEEN]    = "EVENT_INTERFACE_TEEN";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_CHAP]    = "EVENT_INTERFACE_CHAP";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_LIST]    = "EVENT_INTERFACE_LIST";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_RESUME]  = "EVENT_INTERFACE_RESUME";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PLAY]    = "EVENT_INTERFACE_PLAY";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_SETUPd]  = "EVENT_INTERFACE_SETUPd";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_SETUPg]  = "EVENT_INTERFACE_SETUPg";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_SETUPp]  = "EVENT_INTERFACE_SETUPp";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_SETUPc]  = "EVENT_INTERFACE_SETUPc";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_SETUPs]  = "EVENT_INTERFACE_SETUPs";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_DEVICE]  = "EVENT_INTERFACE_DEVICE";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_RESOL]   = "EVENT_INTERFACE_RESOL";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_FULL]    = "EVENT_INTERFACE_FULL";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_APPLY]   = "EVENT_INTERFACE_APPLY";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_TOTO]    = "EVENT_INTERFACE_TOTO";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_SHADOW]  = "EVENT_INTERFACE_SHADOW";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_DIRTY]   = "EVENT_INTERFACE_DIRTY";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_LENS]    = "EVENT_INTERFACE_LENS";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_SKY]     = "EVENT_INTERFACE_SKY";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PLANET]  = "EVENT_INTERFACE_PLANET";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_LIGHT]   = "EVENT_INTERFACE_LIGHT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PARTI]   = "EVENT_INTERFACE_PARTI";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_CLIP]    = "EVENT_INTERFACE_CLIP";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_DETAIL]  = "EVENT_INTERFACE_DETAIL";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_TEXTURE] = "EVENT_INTERFACE_TEXTURE";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_RAIN]    = "EVENT_INTERFACE_RAIN";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_GLINT]   = "EVENT_INTERFACE_GLINT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_TOOLTIP] = "EVENT_INTERFACE_TOOLTIP";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_MOVIES]  = "EVENT_INTERFACE_MOVIES";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_NICERST] = "EVENT_INTERFACE_NICERST";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_SCROLL]  = "EVENT_INTERFACE_SCROLL";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_INVERTX] = "EVENT_INTERFACE_INVERTX";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_INVERTY] = "EVENT_INTERFACE_INVERTY";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_EFFECT]  = "EVENT_INTERFACE_EFFECT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_MOUSE]   = "EVENT_INTERFACE_MOUSE";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_GROUND]  = "EVENT_INTERFACE_GROUND";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_GADGET]  = "EVENT_INTERFACE_GADGET";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_FOG]     = "EVENT_INTERFACE_FOG";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_HIMSELF] = "EVENT_INTERFACE_HIMSELF";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_EDITMODE]= "EVENT_INTERFACE_EDITMODE";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_EDITVALUE]= "EVENT_INTERFACE_EDITVALUE";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_SOLUCE4] = "EVENT_INTERFACE_SOLUCE4";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KINFO1]  = "EVENT_INTERFACE_KINFO1";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KINFO2]  = "EVENT_INTERFACE_KINFO2";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KGROUP]  = "EVENT_INTERFACE_KGROUP";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KSCROLL] = "EVENT_INTERFACE_KSCROLL";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KDEF]    = "EVENT_INTERFACE_KDEF";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KLEFT]   = "EVENT_INTERFACE_KLEFT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KRIGHT]  = "EVENT_INTERFACE_KRIGHT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KUP]     = "EVENT_INTERFACE_KUP";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KDOWN]   = "EVENT_INTERFACE_KDOWN";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KGUP]    = "EVENT_INTERFACE_KGUP";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KGDOWN]  = "EVENT_INTERFACE_KGDOWN";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KCAMERA] = "EVENT_INTERFACE_KCAMERA";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KDESEL]  = "EVENT_INTERFACE_KDESEL";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KACTION] = "EVENT_INTERFACE_KACTION";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KNEAR]   = "EVENT_INTERFACE_KNEAR";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KAWAY]   = "EVENT_INTERFACE_KAWAY";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KNEXT]   = "EVENT_INTERFACE_KNEXT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KHUMAN]  = "EVENT_INTERFACE_KHUMAN";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KQUIT]   = "EVENT_INTERFACE_KQUIT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KHELP]   = "EVENT_INTERFACE_KHELP";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KPROG]   = "EVENT_INTERFACE_KPROG";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KCBOT]   = "EVENT_INTERFACE_KCBOT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KVISIT]  = "EVENT_INTERFACE_KVISIT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KSPEED10]= "EVENT_INTERFACE_KSPEED10";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KSPEED15]= "EVENT_INTERFACE_KSPEED15";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KSPEED20]= "EVENT_INTERFACE_KSPEED20";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_KSPEED30]= "EVENT_INTERFACE_KSPEED30";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_VOLSOUND]= "EVENT_INTERFACE_VOLSOUND";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_VOLMUSIC]= "EVENT_INTERFACE_VOLMUSIC";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_SOUND3D] = "EVENT_INTERFACE_SOUND3D";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_MIN]     = "EVENT_INTERFACE_MIN";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_NORM]    = "EVENT_INTERFACE_NORM";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_MAX]     = "EVENT_INTERFACE_MAX";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_SILENT]  = "EVENT_INTERFACE_SILENT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_NOISY]   = "EVENT_INTERFACE_NOISY";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_JOYSTICK]= "EVENT_INTERFACE_JOYSTICK";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_SOLUCE]  = "EVENT_INTERFACE_SOLUCE";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_GLINTl]  = "EVENT_INTERFACE_GLINTl";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_GLINTr]  = "EVENT_INTERFACE_GLINTr";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_GLINTu]  = "EVENT_INTERFACE_GLINTu";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_GLINTb]  = "EVENT_INTERFACE_GLINTb";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_NEDIT]   = "EVENT_INTERFACE_NEDIT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_NLIST]   = "EVENT_INTERFACE_NLIST";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_NOK]     = "EVENT_INTERFACE_NOK";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_NCANCEL] = "EVENT_INTERFACE_NCANCEL";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_NDELETE] = "EVENT_INTERFACE_NDELETE";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_NLABEL]  = "EVENT_INTERFACE_NLABEL";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_IOWRITE] = "EVENT_INTERFACE_IOWRITE";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_IOREAD]  = "EVENT_INTERFACE_IOREAD";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_IOLIST]  = "EVENT_INTERFACE_IOLIST";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_IONAME]  = "EVENT_INTERFACE_IONAME";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_IOLABEL] = "EVENT_INTERFACE_IOLABEL";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_IOIMAGE] = "EVENT_INTERFACE_IOIMAGE";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_IODELETE]= "EVENT_INTERFACE_IODELETE";
+
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PERSO]   = "EVENT_INTERFACE_PERSO";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_POK]     = "EVENT_INTERFACE_POK";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PCANCEL] = "EVENT_INTERFACE_PCANCEL";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PDEF]    = "EVENT_INTERFACE_PDEF";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PHEAD]   = "EVENT_INTERFACE_PHEAD";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PBODY]   = "EVENT_INTERFACE_PBODY";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PLROT]   = "EVENT_INTERFACE_PLROT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PRROT]   = "EVENT_INTERFACE_PRROT";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC0a]    = "EVENT_INTERFACE_PC0a";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC1a]    = "EVENT_INTERFACE_PC1a";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC2a]    = "EVENT_INTERFACE_PC2a";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC3a]    = "EVENT_INTERFACE_PC3a";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC4a]    = "EVENT_INTERFACE_PC4a";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC5a]    = "EVENT_INTERFACE_PC5a";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC6a]    = "EVENT_INTERFACE_PC6a";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC7a]    = "EVENT_INTERFACE_PC7a";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC8a]    = "EVENT_INTERFACE_PC8a";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC9a]    = "EVENT_INTERFACE_PC9a";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PCRa]    = "EVENT_INTERFACE_PCRa";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PCGa]    = "EVENT_INTERFACE_PCGa";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PCBa]    = "EVENT_INTERFACE_PCBa";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC0b]    = "EVENT_INTERFACE_PC0b";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC1b]    = "EVENT_INTERFACE_PC1b";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC2b]    = "EVENT_INTERFACE_PC2b";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC3b]    = "EVENT_INTERFACE_PC3b";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC4b]    = "EVENT_INTERFACE_PC4b";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC5b]    = "EVENT_INTERFACE_PC5b";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC6b]    = "EVENT_INTERFACE_PC6b";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC7b]    = "EVENT_INTERFACE_PC7b";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC8b]    = "EVENT_INTERFACE_PC8b";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PC9b]    = "EVENT_INTERFACE_PC9b";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PCRb]    = "EVENT_INTERFACE_PCRb";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PCGb]    = "EVENT_INTERFACE_PCGb";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PCBb]    = "EVENT_INTERFACE_PCBb";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PFACE1]  = "EVENT_INTERFACE_PFACE1";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PFACE2]  = "EVENT_INTERFACE_PFACE2";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PFACE3]  = "EVENT_INTERFACE_PFACE3";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PFACE4]  = "EVENT_INTERFACE_PFACE4";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PGLASS0] = "EVENT_INTERFACE_PGLASS0";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PGLASS1] = "EVENT_INTERFACE_PGLASS1";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PGLASS2] = "EVENT_INTERFACE_PGLASS2";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PGLASS3] = "EVENT_INTERFACE_PGLASS3";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PGLASS4] = "EVENT_INTERFACE_PGLASS4";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PGLASS5] = "EVENT_INTERFACE_PGLASS5";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PGLASS6] = "EVENT_INTERFACE_PGLASS6";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PGLASS7] = "EVENT_INTERFACE_PGLASS7";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PGLASS8] = "EVENT_INTERFACE_PGLASS8";
+    EVENT_TYPE_TEXT[EVENT_INTERFACE_PGLASS9] = "EVENT_INTERFACE_PGLASS9";
+
+    EVENT_TYPE_TEXT[EVENT_DT_GROUP0]         = "EVENT_DT_GROUP0";
+    EVENT_TYPE_TEXT[EVENT_DT_GROUP1]         = "EVENT_DT_GROUP1";
+    EVENT_TYPE_TEXT[EVENT_DT_GROUP2]         = "EVENT_DT_GROUP2";
+    EVENT_TYPE_TEXT[EVENT_DT_GROUP3]         = "EVENT_DT_GROUP3";
+    EVENT_TYPE_TEXT[EVENT_DT_GROUP4]         = "EVENT_DT_GROUP4";
+    EVENT_TYPE_TEXT[EVENT_DT_LABEL0]         = "EVENT_DT_LABEL0";
+    EVENT_TYPE_TEXT[EVENT_DT_LABEL1]         = "EVENT_DT_LABEL1";
+    EVENT_TYPE_TEXT[EVENT_DT_LABEL2]         = "EVENT_DT_LABEL2";
+    EVENT_TYPE_TEXT[EVENT_DT_LABEL3]         = "EVENT_DT_LABEL3";
+    EVENT_TYPE_TEXT[EVENT_DT_LABEL4]         = "EVENT_DT_LABEL4";
+    EVENT_TYPE_TEXT[EVENT_DT_VISIT0]         = "EVENT_DT_VISIT0";
+    EVENT_TYPE_TEXT[EVENT_DT_VISIT1]         = "EVENT_DT_VISIT1";
+    EVENT_TYPE_TEXT[EVENT_DT_VISIT2]         = "EVENT_DT_VISIT2";
+    EVENT_TYPE_TEXT[EVENT_DT_VISIT3]         = "EVENT_DT_VISIT3";
+    EVENT_TYPE_TEXT[EVENT_DT_VISIT4]         = "EVENT_DT_VISIT4";
+    EVENT_TYPE_TEXT[EVENT_DT_END]            = "EVENT_DT_END";
+
+    EVENT_TYPE_TEXT[EVENT_CMD]               = "EVENT_CMD";
+    EVENT_TYPE_TEXT[EVENT_SPEED]             = "EVENT_SPEED";
+
+    EVENT_TYPE_TEXT[EVENT_HYPER_PREV]        = "EVENT_HYPER_PREV";
+    EVENT_TYPE_TEXT[EVENT_HYPER_NEXT]        = "EVENT_HYPER_NEXT";
+    EVENT_TYPE_TEXT[EVENT_HYPER_HOME]        = "EVENT_HYPER_HOME";
+    EVENT_TYPE_TEXT[EVENT_HYPER_COPY]        = "EVENT_HYPER_COPY";
+    EVENT_TYPE_TEXT[EVENT_HYPER_SIZE1]       = "EVENT_HYPER_SIZE1";
+    EVENT_TYPE_TEXT[EVENT_HYPER_SIZE2]       = "EVENT_HYPER_SIZE2";
+    EVENT_TYPE_TEXT[EVENT_HYPER_SIZE3]       = "EVENT_HYPER_SIZE3";
+    EVENT_TYPE_TEXT[EVENT_HYPER_SIZE4]       = "EVENT_HYPER_SIZE4";
+    EVENT_TYPE_TEXT[EVENT_HYPER_SIZE5]       = "EVENT_HYPER_SIZE5";
+
+    EVENT_TYPE_TEXT[EVENT_SATCOM_HUSTON]     = "EVENT_SATCOM_HUSTON";
+    EVENT_TYPE_TEXT[EVENT_SATCOM_SAT]        = "EVENT_SATCOM_SAT";
+    EVENT_TYPE_TEXT[EVENT_SATCOM_LOADING]    = "EVENT_SATCOM_LOADING";
+    EVENT_TYPE_TEXT[EVENT_SATCOM_OBJECT]     = "EVENT_SATCOM_OBJECT";
+    EVENT_TYPE_TEXT[EVENT_SATCOM_PROG]       = "EVENT_SATCOM_PROG";
+    EVENT_TYPE_TEXT[EVENT_SATCOM_SOLUCE]     = "EVENT_SATCOM_SOLUCE";
+
+    EVENT_TYPE_TEXT[EVENT_OBJECT_DESELECT]   = "EVENT_OBJECT_DESELECT";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_LEFT]       = "EVENT_OBJECT_LEFT";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_RIGHT]      = "EVENT_OBJECT_RIGHT";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_UP]         = "EVENT_OBJECT_UP";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_DOWN]       = "EVENT_OBJECT_DOWN";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_GASUP]      = "EVENT_OBJECT_GASUP";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_GASDOWN]    = "EVENT_OBJECT_GASDOWN";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_HTAKE]      = "EVENT_OBJECT_HTAKE";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_MTAKE]      = "EVENT_OBJECT_MTAKE";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_MFRONT]     = "EVENT_OBJECT_MFRONT";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_MBACK]      = "EVENT_OBJECT_MBACK";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_MPOWER]     = "EVENT_OBJECT_MPOWER";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BHELP]      = "EVENT_OBJECT_BHELP";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BTAKEOFF]   = "EVENT_OBJECT_BTAKEOFF";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BDESTROY]   = "EVENT_OBJECT_BDESTROY";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BDERRICK]   = "EVENT_OBJECT_BDERRICK";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BSTATION]   = "EVENT_OBJECT_BSTATION";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BFACTORY]   = "EVENT_OBJECT_BFACTORY";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BCONVERT]   = "EVENT_OBJECT_BCONVERT";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BTOWER]     = "EVENT_OBJECT_BTOWER";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BREPAIR]    = "EVENT_OBJECT_BREPAIR";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BRESEARCH]  = "EVENT_OBJECT_BRESEARCH";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BRADAR]     = "EVENT_OBJECT_BRADAR";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BENERGY]    = "EVENT_OBJECT_BENERGY";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BLABO]      = "EVENT_OBJECT_BLABO";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BNUCLEAR]   = "EVENT_OBJECT_BNUCLEAR";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BPARA]      = "EVENT_OBJECT_BPARA";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BINFO]      = "EVENT_OBJECT_BINFO";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BDESTROYER] = "EVENT_OBJECT_BDESTROYER";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_GFLAT]      = "EVENT_OBJECT_GFLAT";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FCREATE]    = "EVENT_OBJECT_FCREATE";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FDELETE]    = "EVENT_OBJECT_FDELETE";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FCOLORb]    = "EVENT_OBJECT_FCOLORb";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FCOLORr]    = "EVENT_OBJECT_FCOLORr";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FCOLORg]    = "EVENT_OBJECT_FCOLORg";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FCOLORy]    = "EVENT_OBJECT_FCOLORy";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FCOLORv]    = "EVENT_OBJECT_FCOLORv";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYwa]  = "EVENT_OBJECT_FACTORYwa";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYta]  = "EVENT_OBJECT_FACTORYta";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYfa]  = "EVENT_OBJECT_FACTORYfa";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYia]  = "EVENT_OBJECT_FACTORYia";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYwc]  = "EVENT_OBJECT_FACTORYwc";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYtc]  = "EVENT_OBJECT_FACTORYtc";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYfc]  = "EVENT_OBJECT_FACTORYfc";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYic]  = "EVENT_OBJECT_FACTORYic";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYwi]  = "EVENT_OBJECT_FACTORYwi";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYti]  = "EVENT_OBJECT_FACTORYti";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYfi]  = "EVENT_OBJECT_FACTORYfi";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYii]  = "EVENT_OBJECT_FACTORYii";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYws]  = "EVENT_OBJECT_FACTORYws";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYts]  = "EVENT_OBJECT_FACTORYts";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYfs]  = "EVENT_OBJECT_FACTORYfs";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYis]  = "EVENT_OBJECT_FACTORYis";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYrt]  = "EVENT_OBJECT_FACTORYrt";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYrc]  = "EVENT_OBJECT_FACTORYrc";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYrr]  = "EVENT_OBJECT_FACTORYrr";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYrs]  = "EVENT_OBJECT_FACTORYrs";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FACTORYsa]  = "EVENT_OBJECT_FACTORYsa";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SEARCH]     = "EVENT_OBJECT_SEARCH";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_TERRAFORM]  = "EVENT_OBJECT_TERRAFORM";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FIRE]       = "EVENT_OBJECT_FIRE";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_FIREANT]    = "EVENT_OBJECT_FIREANT";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SPIDEREXPLO]= "EVENT_OBJECT_SPIDEREXPLO";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_RECOVER]    = "EVENT_OBJECT_RECOVER";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_BEGSHIELD]  = "EVENT_OBJECT_BEGSHIELD";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_ENDSHIELD]  = "EVENT_OBJECT_ENDSHIELD";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_RTANK]      = "EVENT_OBJECT_RTANK";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_RFLY]       = "EVENT_OBJECT_RFLY";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_RTHUMP]     = "EVENT_OBJECT_RTHUMP";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_RCANON]     = "EVENT_OBJECT_RCANON";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_RTOWER]     = "EVENT_OBJECT_RTOWER";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_RPHAZER]    = "EVENT_OBJECT_RPHAZER";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_RSHIELD]    = "EVENT_OBJECT_RSHIELD";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_RATOMIC]    = "EVENT_OBJECT_RATOMIC";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_RiPAW]      = "EVENT_OBJECT_RiPAW";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_RiGUN]      = "EVENT_OBJECT_RiGUN";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_RESET]      = "EVENT_OBJECT_RESET";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_DIMSHIELD]  = "EVENT_OBJECT_DIMSHIELD";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_TARGET]     = "EVENT_OBJECT_TARGET";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PROGLIST]   = "EVENT_OBJECT_PROGLIST";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PROGRUN]    = "EVENT_OBJECT_PROGRUN";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PROGEDIT]   = "EVENT_OBJECT_PROGEDIT";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PROGSTART]  = "EVENT_OBJECT_PROGSTART";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PROGSTOP]   = "EVENT_OBJECT_PROGSTOP";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_INFOOK]     = "EVENT_OBJECT_INFOOK";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_DELETE]     = "EVENT_OBJECT_DELETE";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_GENERGY]    = "EVENT_OBJECT_GENERGY";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_GSHIELD]    = "EVENT_OBJECT_GSHIELD";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_GRANGE]     = "EVENT_OBJECT_GRANGE";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_COMPASS]    = "EVENT_OBJECT_COMPASS";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_MAP]        = "EVENT_OBJECT_MAP";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_MAPZOOM]    = "EVENT_OBJECT_MAPZOOM";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_GPROGRESS]  = "EVENT_OBJECT_GPROGRESS";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_GRADAR]     = "EVENT_OBJECT_GRADAR";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_GINFO]      = "EVENT_OBJECT_GINFO";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_TYPE]       = "EVENT_OBJECT_TYPE";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_CROSSHAIR]  = "EVENT_OBJECT_CROSSHAIR";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_CORNERul]   = "EVENT_OBJECT_CORNERul";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_CORNERur]   = "EVENT_OBJECT_CORNERur";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_CORNERdl]   = "EVENT_OBJECT_CORNERdl";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_CORNERdr]   = "EVENT_OBJECT_CORNERdr";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_MAPi]       = "EVENT_OBJECT_MAPi";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_MAPg]       = "EVENT_OBJECT_MAPg";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_CAMERA]     = "EVENT_OBJECT_CAMERA";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_HELP]       = "EVENT_OBJECT_HELP";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SOLUCE]     = "EVENT_OBJECT_SOLUCE";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_CAMERAleft] = "EVENT_OBJECT_CAMERAleft";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_CAMERAright]= "EVENT_OBJECT_CAMERAright";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_CAMERAnear] = "EVENT_OBJECT_CAMERAnear";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_CAMERAaway] = "EVENT_OBJECT_CAMERAaway";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT00] = "EVENT_OBJECT_SHORTCUT00";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT01] = "EVENT_OBJECT_SHORTCUT01";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT02] = "EVENT_OBJECT_SHORTCUT02";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT03] = "EVENT_OBJECT_SHORTCUT03";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT04] = "EVENT_OBJECT_SHORTCUT04";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT05] = "EVENT_OBJECT_SHORTCUT05";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT06] = "EVENT_OBJECT_SHORTCUT06";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT07] = "EVENT_OBJECT_SHORTCUT07";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT08] = "EVENT_OBJECT_SHORTCUT08";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT09] = "EVENT_OBJECT_SHORTCUT09";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT10] = "EVENT_OBJECT_SHORTCUT10";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT11] = "EVENT_OBJECT_SHORTCUT11";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT12] = "EVENT_OBJECT_SHORTCUT12";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT13] = "EVENT_OBJECT_SHORTCUT13";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT14] = "EVENT_OBJECT_SHORTCUT14";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT15] = "EVENT_OBJECT_SHORTCUT15";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT16] = "EVENT_OBJECT_SHORTCUT16";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT17] = "EVENT_OBJECT_SHORTCUT17";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT18] = "EVENT_OBJECT_SHORTCUT18";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_SHORTCUT19] = "EVENT_OBJECT_SHORTCUT19";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_MOVIELOCK]  = "EVENT_OBJECT_MOVIELOCK";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_EDITLOCK]   = "EVENT_OBJECT_EDITLOCK";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_LIMIT]      = "EVENT_OBJECT_LIMIT";
+
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PEN0]       = "EVENT_OBJECT_PEN0";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PEN1]       = "EVENT_OBJECT_PEN1";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PEN2]       = "EVENT_OBJECT_PEN2";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PEN3]       = "EVENT_OBJECT_PEN3";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PEN4]       = "EVENT_OBJECT_PEN4";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PEN5]       = "EVENT_OBJECT_PEN5";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PEN6]       = "EVENT_OBJECT_PEN6";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PEN7]       = "EVENT_OBJECT_PEN7";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_PEN8]       = "EVENT_OBJECT_PEN8";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_REC]        = "EVENT_OBJECT_REC";
+    EVENT_TYPE_TEXT[EVENT_OBJECT_STOP]       = "EVENT_OBJECT_STOP";
+
+    EVENT_TYPE_TEXT[EVENT_STUDIO_OK]         = "EVENT_STUDIO_OK";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_CANCEL]     = "EVENT_STUDIO_CANCEL";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_EDIT]       = "EVENT_STUDIO_EDIT";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_LIST]       = "EVENT_STUDIO_LIST";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_NEW]        = "EVENT_STUDIO_NEW";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_OPEN]       = "EVENT_STUDIO_OPEN";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_SAVE]       = "EVENT_STUDIO_SAVE";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_UNDO]       = "EVENT_STUDIO_UNDO";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_CUT]        = "EVENT_STUDIO_CUT";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_COPY]       = "EVENT_STUDIO_COPY";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_PASTE]      = "EVENT_STUDIO_PASTE";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_SIZE]       = "EVENT_STUDIO_SIZE";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_TOOL]       = "EVENT_STUDIO_TOOL";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_HELP]       = "EVENT_STUDIO_HELP";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_COMPILE]    = "EVENT_STUDIO_COMPILE";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_RUN]        = "EVENT_STUDIO_RUN";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_REALTIME]   = "EVENT_STUDIO_REALTIME";
+    EVENT_TYPE_TEXT[EVENT_STUDIO_STEP]       = "EVENT_STUDIO_STEP";
+}
+
+std::string ParseEventType(EventType eventType)
 {
-    int i = static_cast<int>(g_uniqueEventType+1);
-    g_uniqueEventType = static_cast<EventType>(i);
-    return g_uniqueEventType;
+    auto Other = [&](const char* name)
+    {
+        std::stringstream str;
+        str << name << "(" << static_cast<int>(eventType) << ")";
+        return str.str();
+    };
+
+    if (eventType < EVENT_STD_MAX)
+    {
+        const char* stdEvent = EVENT_TYPE_TEXT[eventType];
+        if (stdEvent[0] == 0)
+            return Other("STD_UNDEFINED");
+
+        return stdEvent;
+    }
+
+    if (eventType >= EVENT_USER)
+        return Other("USER_EVENT");
+
+    return Other("UNDEFINED");
 }
 
 
diff --git a/src/common/event.h b/src/common/event.h
index 8aef603..9405660 100644
--- a/src/common/event.h
+++ b/src/common/event.h
@@ -40,8 +40,10 @@ enum EventType
     //! Invalid event / no event
     EVENT_NULL              = 0,
 
-    //! Event sent on user or system quit request
-    EVENT_QUIT              = 1,
+    // System events (originating in CApplication)
+
+    //! Event sent on system quit request
+    EVENT_SYS_QUIT          = 1,
 
     //! Frame update event
     EVENT_FRAME             = 2,
@@ -69,10 +71,15 @@ enum EventType
     //! Event sent after releasing a joystick button
     EVENT_JOY_BUTTON_UP     = 14,
 
+    //!< Maximum value of system events
+    EVENT_SYS_MAX,
+
 
     /* Events sent/received in game and user interface */
 
-    EVENT_UPDINTERFACE      = 20,
+    //! Event sent on user quit request
+    EVENT_QUIT              = 20,
+    EVENT_UPDINTERFACE      = 21,
     EVENT_WIN               = 30,
     EVENT_LOST              = 31,
 
@@ -548,7 +555,8 @@ enum EventType
     EVENT_STUDIO_REALTIME   = 2052,
     EVENT_STUDIO_STEP       = 2053,
 
-    EVENT_STD_MAX, //! < maximum value of standard events
+    //! Maximum value of standard events
+    EVENT_STD_MAX,
 
     EVENT_USER              = 10000,
     EVENT_FORCE_LONG        = 0x7fffffff
@@ -669,8 +677,8 @@ struct ActiveEventData
  * \struct Event
  * \brief Event sent by system, interface or game
  *
- * Event is described by its type (EventType) and the union
- * \a data contains additional data about the event.
+ * Event is described by its type (EventType) and anonymous union that
+ * contains additional data about the event.
  * Different members of the union are filled with different event types.
  * With some events, nothing is filled (it's zeroed out).
  * The union contains roughly the same information as SDL_Event struct
@@ -681,9 +689,6 @@ struct Event
     //! Type of event
     EventType type;
 
-    //! If true, the event was produced by system in CApplication; else, it has come from game engine
-    bool systemEvent;
-
     //! Relative time since last EVENT_FRAME
     //! Scope: only EVENT_FRAME events
     // TODO: gradually replace the usage of this with new CApplication's time functions
@@ -732,7 +737,6 @@ struct Event
 
     explicit Event(EventType _type = EVENT_NULL)
      : type(_type)
-     , systemEvent(false)
      , rTime(0.0f)
      , kmodState(0)
      , trackedKeysState(0)
@@ -745,6 +749,11 @@ struct Event
 //! Returns an unique event type (above the standard IDs)
 EventType GetUniqueEventType();
 
+//! Initializes static array with event type strings
+void InitializeEventTypeTexts();
+
+//! Parses event type to string
+std::string ParseEventType(EventType eventType);
 
 /**
  * \class CEventQueue
diff --git a/src/common/profile.h b/src/common/profile.h
index 8ea2aee..f084ece 100644
--- a/src/common/profile.h
+++ b/src/common/profile.h
@@ -43,7 +43,7 @@ class CProfile : public CSingleton<CProfile>
 {
 public:
     CProfile();
-    ~CProfile();
+    virtual ~CProfile();
 
     /** Loads colobot.ini from current directory
         * \return return true on success
diff --git a/src/common/restext.cpp b/src/common/restext.cpp
index ead8ef3..d61fa63 100644
--- a/src/common/restext.cpp
+++ b/src/common/restext.cpp
@@ -848,10 +848,8 @@ static const char* GetResourceBase(ResType type, int num)
 
         case RES_EVENT:
             if (num >= EVENT_STD_MAX)
-            {
-                GetLogger()->Trace("GetResource event num out of range: %d\n", num); // TODO: fix later
-                return "";
-            }
+                return ""; // can be safely ignored (user events)
+
             str = stringsEvent[num];
             break;
 
diff --git a/src/graphics/core/device.h b/src/graphics/core/device.h
index 38bc463..4c1189c 100644
--- a/src/graphics/core/device.h
+++ b/src/graphics/core/device.h
@@ -240,6 +240,9 @@ public:
     //! Provides a hook to debug graphics code (implementation-specific)
     virtual void DebugHook() = 0;
 
+    //! Displays light positions to aid in debuggings
+    virtual void DebugLights() = 0;
+
     //! Initializes the device, setting the initial state
     virtual bool Create() = 0;
     //! Destroys the device, releasing every acquired resource
diff --git a/src/graphics/engine/engine.cpp b/src/graphics/engine/engine.cpp
index 4d0687a..669ea42 100644
--- a/src/graphics/engine/engine.cpp
+++ b/src/graphics/engine/engine.cpp
@@ -128,6 +128,9 @@ CEngine::CEngine(CApplication *app)
 
     m_interfaceMode = false;
 
+    m_debugLights = false;
+    m_debugDumpLights = false;
+
     m_mice[ENG_MOUSE_NORM]    = EngineMouse( 0,  1, 32, ENG_RSTATE_TTEXTURE_WHITE, ENG_RSTATE_TTEXTURE_BLACK, Math::Point( 1.0f,  1.0f));
     m_mice[ENG_MOUSE_WAIT]    = EngineMouse( 2,  3, 33, ENG_RSTATE_TTEXTURE_WHITE, ENG_RSTATE_TTEXTURE_BLACK, Math::Point( 8.0f, 12.0f));
     m_mice[ENG_MOUSE_HAND]    = EngineMouse( 4,  5, 34, ENG_RSTATE_TTEXTURE_WHITE, ENG_RSTATE_TTEXTURE_BLACK, Math::Point( 7.0f,  2.0f));
@@ -325,7 +328,22 @@ bool CEngine::ProcessEvent(const Event &event)
     if (event.type == EVENT_KEY_DOWN)
     {
         if (event.key.key == KEY(F12))
+        {
             m_showStats = !m_showStats;
+            return false;
+        }
+
+        if (event.key.key == KEY(F11))
+        {
+            m_debugLights = !m_debugLights;
+            return false;
+        }
+
+        if (event.key.key == KEY(F10))
+        {
+            m_debugDumpLights = true;
+            return false;
+        }
     }
 
     // By default, pass on all events
@@ -698,6 +716,82 @@ void CEngine::AddBaseObjQuick(int baseObjRank, const EngineBaseObjDataTier& buff
         p1.totalTriangles += p4.vertices.size() - 2;
 }
 
+void CEngine::DebugObject(int objRank)
+{
+    assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
+
+    CLogger* l = GetLogger();
+
+    l->Debug("Debug object: %d\n", objRank);
+    if (! m_objects[objRank].used)
+    {
+        l->Debug(" not used\n");
+        return;
+    }
+
+    l->Debug(" baseObjRank = %d\n", m_objects[objRank].baseObjRank);
+    l->Debug(" visible = %s\n", m_objects[objRank].visible ? "true" : "false");
+    l->Debug(" drawWorld = %s\n", m_objects[objRank].drawWorld ? "true" : "false");
+    l->Debug(" drawFront = %s\n", m_objects[objRank].drawFront ? "true" : "false");
+    l->Debug(" type = %d\n", m_objects[objRank].type);
+    l->Debug(" distance = %f\n", m_objects[objRank].distance);
+    l->Debug(" shadowRank = %d\n", m_objects[objRank].shadowRank);
+    l->Debug(" transparency = %f\n", m_objects[objRank].transparency);
+
+    l->Debug(" baseObj:\n");
+    int baseObjRank = m_objects[objRank].baseObjRank;
+    if (baseObjRank == -1)
+    {
+        l->Debug("  null\n");
+        return;
+    }
+
+    assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
+
+    EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+    if (!p1.used)
+    {
+        l->Debug("  not used\n");
+        return;
+    }
+
+    std::string vecStr;
+
+    vecStr = p1.bboxMin.ToString();
+    l->Debug("  bboxMin: %s\n", vecStr.c_str());
+    vecStr = p1.bboxMax.ToString();
+    l->Debug("  bboxMax: %s\n", vecStr.c_str());
+    l->Debug("  totalTriangles: %d\n", p1.totalTriangles);
+    l->Debug("  radius: %f\n", p1.radius);
+
+    for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
+    {
+        EngineBaseObjTexTier& p2 = p1.next[l2];
+        l->Debug("  l2:\n");
+
+        l->Debug("   tex1: %s (id: %u)\n", p2.tex1Name.c_str(), p2.tex1.id);
+        l->Debug("   tex2: %s (id: %u)\n", p2.tex2Name.c_str(), p2.tex2.id);
+
+        for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
+        {
+            EngineBaseObjLODTier& p3 = p2.next[l3];
+
+            l->Debug("    l3:\n");
+            l->Debug("     lodLevel: %d\n", p3.lodLevel);
+
+            for (int l4 = 0; l4 < static_cast<int>( p3.next.size() ); l4++)
+            {
+                EngineBaseObjDataTier& p4 = p3.next[l4];
+
+                l->Debug("     l4:\n");
+                l->Debug("      type: %d\n", p4.type);
+                l->Debug("      state: %d\n", p4.state);
+                l->Debug("      staticBufferId: %u\n", p4.staticBufferId);
+                l->Debug("      updateStaticBuffer: %s\n", p4.updateStaticBuffer ? "true" : "false");
+            }
+        }
+    }
+}
 
 int CEngine::CreateObject()
 {
@@ -986,14 +1080,19 @@ void CEngine::ChangeSecondTexture(int objRank, const std::string& tex2Name)
 
     for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
     {
-        EngineBaseObjTexTier& p2 = p1.next[l2];
-
-        if (p2.tex2Name == tex2Name)
+        if (p1.next[l2].tex2Name == tex2Name)
             continue;  // already new
 
-        EngineBaseObjTexTier& newP2 = AddLevel2(p1, p2.tex1Name, tex2Name);
-        newP2.next.insert(newP2.next.end(), p2.next.begin(), p2.next.end());
-        p2.next.clear();
+        std::string tex1Name = p1.next[l2].tex1Name;
+        EngineBaseObjTexTier& newP2 = AddLevel2(p1, tex1Name, tex2Name);
+        newP2.next.insert(newP2.next.end(), p1.next[l2].next.begin(), p1.next[l2].next.end());
+        p1.next[l2].next.clear();
+
+        if (!newP2.tex1.Valid())
+            newP2.tex1 = LoadTexture(newP2.tex1Name);
+
+        if (!newP2.tex2.Valid())
+            newP2.tex2 = LoadTexture(newP2.tex2Name);
     }
 }
 
@@ -2156,7 +2255,7 @@ Texture CEngine::CreateTexture(const std::string& texName, const TextureCreatePa
         image = &img;
     }
 
-    tex = m_device->CreateTexture(&img, params);
+    tex = m_device->CreateTexture(image, params);
 
     if (! tex.Valid())
     {
@@ -3212,6 +3311,15 @@ void CEngine::Draw3DScene()
 
     m_lightMan->UpdateDeviceLights(ENG_OBJTYPE_TERRAIN);
 
+    if (m_debugLights)
+        m_device->DebugLights();
+
+    if (m_debugDumpLights)
+    {
+        m_debugDumpLights = false;
+        m_lightMan->DebugDumpLights();
+    }
+
     if (m_waterMode)
     {
         m_app->StartPerformanceCounter(PCNT_RENDER_WATER);
diff --git a/src/graphics/engine/engine.h b/src/graphics/engine/engine.h
index 27aa5dc..5ecde8f 100644
--- a/src/graphics/engine/engine.h
+++ b/src/graphics/engine/engine.h
@@ -118,7 +118,7 @@ enum EngineRenderState
     //! Mode for rendering text
     ENG_RSTATE_TEXT             = (1<<18),
     //! Only opaque texture, no blending, etc.
-    ENG_RSTATE_OPAQUE_TEXTURE     = (1<<19),
+    ENG_RSTATE_OPAQUE_TEXTURE   = (1<<19),
     //! Only opaque color, no texture, blending, etc.
     ENG_RSTATE_OPAQUE_COLOR     = (1<<20)
 };
@@ -807,6 +807,9 @@ public:
 
     // Objects
 
+    //! Print debug info about an object
+    void            DebugObject(int rank);
+
     //! Creates a new object and returns its rank
     int             CreateObject();
     //! Deletes all objects, shadows and ground spots
@@ -1434,6 +1437,9 @@ protected:
 
     //! True when drawing 2D UI
     bool            m_interfaceMode;
+
+    bool            m_debugLights;
+    bool            m_debugDumpLights;
 };
 
 
diff --git a/src/graphics/engine/lightman.cpp b/src/graphics/engine/lightman.cpp
index cbb8509..295b3da 100644
--- a/src/graphics/engine/lightman.cpp
+++ b/src/graphics/engine/lightman.cpp
@@ -71,6 +71,7 @@ void LightProgression::SetTarget(float value)
 
 DynamicLight::DynamicLight()
 {
+    rank = 0;
     used = enabled = false;
     priority = LIGHT_PRI_LOW;
     includeType = excludeType = ENG_OBJTYPE_NULL;
@@ -98,6 +99,61 @@ void CLightManager::SetDevice(CDevice* device)
     m_lightMap = std::vector<int>(m_device->GetMaxLightCount(), -1);
 }
 
+void CLightManager::DebugDumpLights()
+{
+    CLogger* l = GetLogger();
+
+    l->Debug("Dynamic lights:\n");
+
+    for (int i = 0; i < static_cast<int>( m_dynLights.size() ); ++i)
+    {
+        const DynamicLight& dynLight = m_dynLights[i];
+        if (!dynLight.used)
+            continue;
+
+        int deviceLight = -1;
+        for (int j = 0; j < m_lightMap.size(); ++j)
+        {
+            if (m_lightMap[j] == i)
+            {
+                deviceLight = j;
+                break;
+            }
+        }
+
+        l->Debug(" light %d\n", i);
+        l->Debug("  enabled = %s\n", dynLight.enabled ? "true" : "false");
+        l->Debug("  priority = %d\n", dynLight.priority);
+        l->Debug("  device light = %d\n", deviceLight);
+        l->Debug("  light:\n");
+
+        const Light& light = dynLight.light;
+        std::string str;
+
+        l->Debug("   type = %d\n", light.type);
+        str = light.ambient.ToString();
+        l->Debug("   ambient = %s\n", str.c_str());
+        str = light.diffuse.ToString();
+        l->Debug("   diffuse = %s\n", str.c_str());
+        str = light.specular.ToString();
+        l->Debug("   specular = %s\n", str.c_str());
+        str = light.position.ToString();
+        l->Debug("   position = %s\n", str.c_str());
+        str = light.direction.ToString();
+        l->Debug("   direction = %s\n", str.c_str());
+        l->Debug("   attenuation0 = %f\n", light.attenuation0);
+        l->Debug("   attenuation1 = %f\n", light.attenuation1);
+        l->Debug("   attenuation2 = %f\n", light.attenuation2);
+        l->Debug("   spotAngle = %f\n", light.spotAngle);
+        l->Debug("   spotIntensity = %f\n", light.spotIntensity);
+
+        l->Debug(" intensity: %f\n", dynLight.intensity.current);
+        l->Debug(" color: %f %f %f\n", dynLight.colorRed.current, dynLight.colorGreen.current, dynLight.colorBlue.current);
+        l->Debug(" includeType: %d\n", dynLight.includeType);
+        l->Debug(" excludeType: %d\n", dynLight.excludeType);
+    }
+}
+
 void CLightManager::FlushLights()
 {
     m_dynLights.clear();
@@ -117,6 +173,7 @@ int CLightManager::CreateLight(LightPriority priority)
         m_dynLights.push_back(DynamicLight());
 
     m_dynLights[index] = DynamicLight();
+    m_dynLights[index].rank     = index;
     m_dynLights[index].used     = true;
     m_dynLights[index].enabled  = true;
     m_dynLights[index].priority = priority;
@@ -179,6 +236,15 @@ bool CLightManager::SetLightEnabled(int lightRank, bool enabled)
     return true;
 }
 
+bool CLightManager::SetLightPriority(int lightRank, LightPriority priority)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return false;
+
+    m_dynLights[lightRank].priority = priority;
+    return true;
+}
+
 bool CLightManager::SetLightIncludeType(int lightRank, EngineObjectType type)
 {
     if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
@@ -411,7 +477,7 @@ void CLightManager::UpdateDeviceLights(EngineObjectType type)
 
         if (enabled)
         {
-            m_lightMap[lightMapIndex] = i;
+            m_lightMap[lightMapIndex] = sortedLights[i].rank;
             ++lightMapIndex;
         }
 
@@ -424,8 +490,9 @@ void CLightManager::UpdateDeviceLights(EngineObjectType type)
         int rank = m_lightMap[i];
         if (rank != -1)
         {
-            sortedLights[rank].light.ambient = Gfx::Color(0.2f, 0.2f, 0.2f);
-            m_device->SetLight(i, sortedLights[rank].light);
+            Light light = m_dynLights[rank].light;
+            light.ambient = Gfx::Color(0.2f, 0.2f, 0.2f);
+            m_device->SetLight(i, light);
             m_device->SetLightEnabled(i, true);
         }
         else
@@ -445,6 +512,9 @@ CLightManager::LightsComparator::LightsComparator(Math::Vector eyePos, EngineObj
 
 float CLightManager::LightsComparator::GetLightWeight(const DynamicLight& dynLight)
 {
+    if (dynLight.priority == LIGHT_PRI_HIGHEST)
+        return -1.0f;
+
     bool enabled = true;
     if (!dynLight.used || !dynLight.enabled || dynLight.intensity.current == 0.0f)
         enabled = false;
diff --git a/src/graphics/engine/lightman.h b/src/graphics/engine/lightman.h
index 171299c..9677555 100644
--- a/src/graphics/engine/lightman.h
+++ b/src/graphics/engine/lightman.h
@@ -71,8 +71,9 @@ struct LightProgression
  */
 enum LightPriority
 {
-    LIGHT_PRI_HIGH = 1,
-    LIGHT_PRI_LOW  = 2
+    LIGHT_PRI_HIGHEST = 1, //!< always highest weight (always picked)
+    LIGHT_PRI_HIGH = 2,    //!< high weight
+    LIGHT_PRI_LOW  = 3     //!< low weight
 };
 
 /**
@@ -84,6 +85,9 @@ enum LightPriority
  */
 struct DynamicLight
 {
+    //! Rank (index)
+    int rank;
+
     //! Whether the light is used
     bool used;
     //! Whether the light is turned on
@@ -136,6 +140,9 @@ public:
     //! Sets the device to be used
     void            SetDevice(CDevice* device);
 
+    //! Prints debug info
+    void DebugDumpLights();
+
     //! Clears and disables all lights
     void            FlushLights();
     //! Creates a new dynamic light and returns its index (lightRank)
@@ -148,6 +155,8 @@ public:
     bool            GetLight(int lightRank, Light &light);
     //! Enables/disables the given dynamic light
     bool            SetLightEnabled(int lightRank, bool enable);
+    //! Changes the light priority
+    bool            SetLightPriority(int lightRank, LightPriority priority);
 
     //! Sets what objects are included in given dynamic light
     bool            SetLightIncludeType(int lightRank, EngineObjectType type);
diff --git a/src/graphics/engine/modelfile.cpp b/src/graphics/engine/modelfile.cpp
index 8383b15..99496aa 100644
--- a/src/graphics/engine/modelfile.cpp
+++ b/src/graphics/engine/modelfile.cpp
@@ -310,6 +310,7 @@ bool ReadLineString(std::istream& stream, const std::string& prefix, std::string
 
 
 CModelFile::CModelFile()
+ : m_printDebugInfo(false)
 {
 }
 
@@ -615,23 +616,26 @@ bool CModelFile::ReadModel(std::istream& stream)
         if (m_triangles[i].tex1Name == "plant.png")
             m_triangles[i].state |= ENG_RSTATE_ALPHA;
 
-        GetLogger()->Trace("ModelTriangle %d\n", i+1);
-        std::string s1 = m_triangles[i].p1.ToString();
-        GetLogger()->Trace(" p1: %s\n", s1.c_str());
-        std::string s2 = m_triangles[i].p2.ToString();
-        GetLogger()->Trace(" p2: %s\n", s2.c_str());
-        std::string s3 = m_triangles[i].p3.ToString();
-        GetLogger()->Trace(" p3: %s\n", s3.c_str());
-
-        std::string d = m_triangles[i].material.diffuse.ToString();
-        std::string a = m_triangles[i].material.ambient.ToString();
-        std::string s = m_triangles[i].material.specular.ToString();
-        GetLogger()->Trace(" mat: d: %s  a: %s  s: %s\n", d.c_str(), a.c_str(), s.c_str());
-
-        GetLogger()->Trace(" tex1: %s  tex2: %s\n", m_triangles[i].tex1Name.c_str(),
-                          m_triangles[i].variableTex2 ? "(variable)" : m_triangles[i].tex2Name.c_str());
-        GetLogger()->Trace(" lod level: %d\n", m_triangles[i].lodLevel);
-        GetLogger()->Trace(" state: %ld\n", m_triangles[i].state);
+        if (m_printDebugInfo)
+        {
+            GetLogger()->Trace("ModelTriangle %d\n", i+1);
+            std::string s1 = m_triangles[i].p1.ToString();
+            GetLogger()->Trace(" p1: %s\n", s1.c_str());
+            std::string s2 = m_triangles[i].p2.ToString();
+            GetLogger()->Trace(" p2: %s\n", s2.c_str());
+            std::string s3 = m_triangles[i].p3.ToString();
+            GetLogger()->Trace(" p3: %s\n", s3.c_str());
+
+            std::string d = m_triangles[i].material.diffuse.ToString();
+            std::string a = m_triangles[i].material.ambient.ToString();
+            std::string s = m_triangles[i].material.specular.ToString();
+            GetLogger()->Trace(" mat: d: %s  a: %s  s: %s\n", d.c_str(), a.c_str(), s.c_str());
+
+            GetLogger()->Trace(" tex1: %s  tex2: %s\n", m_triangles[i].tex1Name.c_str(),
+                            m_triangles[i].variableTex2 ? "(variable)" : m_triangles[i].tex2Name.c_str());
+            GetLogger()->Trace(" lod level: %d\n", m_triangles[i].lodLevel);
+            GetLogger()->Trace(" state: %ld\n", m_triangles[i].state);
+        }
     }
 
     return true;
@@ -1093,24 +1097,27 @@ bool CModelFile::ReadBinaryModel(std::istream& stream)
         return false;
     }
 
-    for (int i = 0; i < static_cast<int>( m_triangles.size() ); ++i)
+    if (m_printDebugInfo)
     {
-        GetLogger()->Trace("ModelTriangle %d\n", i+1);
-        std::string s1 = m_triangles[i].p1.ToString();
-        GetLogger()->Trace(" p1: %s\n", s1.c_str());
-        std::string s2 = m_triangles[i].p2.ToString();
-        GetLogger()->Trace(" p2: %s\n", s2.c_str());
-        std::string s3 = m_triangles[i].p3.ToString();
-        GetLogger()->Trace(" p3: %s\n", s3.c_str());
-
-        std::string d = m_triangles[i].material.diffuse.ToString();
-        std::string a = m_triangles[i].material.ambient.ToString();
-        std::string s = m_triangles[i].material.specular.ToString();
-        GetLogger()->Trace(" mat: d: %s  a: %s  s: %s\n", d.c_str(), a.c_str(), s.c_str());
-
-        GetLogger()->Trace(" tex1: %s  tex2: %s\n", m_triangles[i].tex1Name.c_str(), m_triangles[i].tex2Name.c_str());
-        GetLogger()->Trace(" lod level: %d\n", m_triangles[i].lodLevel);
-        GetLogger()->Trace(" state: %ld\n", m_triangles[i].state);
+        for (int i = 0; i < static_cast<int>( m_triangles.size() ); ++i)
+        {
+            GetLogger()->Trace("ModelTriangle %d\n", i+1);
+            std::string s1 = m_triangles[i].p1.ToString();
+            GetLogger()->Trace(" p1: %s\n", s1.c_str());
+            std::string s2 = m_triangles[i].p2.ToString();
+            GetLogger()->Trace(" p2: %s\n", s2.c_str());
+            std::string s3 = m_triangles[i].p3.ToString();
+            GetLogger()->Trace(" p3: %s\n", s3.c_str());
+
+            std::string d = m_triangles[i].material.diffuse.ToString();
+            std::string a = m_triangles[i].material.ambient.ToString();
+            std::string s = m_triangles[i].material.specular.ToString();
+            GetLogger()->Trace(" mat: d: %s  a: %s  s: %s\n", d.c_str(), a.c_str(), s.c_str());
+
+            GetLogger()->Trace(" tex1: %s  tex2: %s\n", m_triangles[i].tex1Name.c_str(), m_triangles[i].tex2Name.c_str());
+            GetLogger()->Trace(" lod level: %d\n", m_triangles[i].lodLevel);
+            GetLogger()->Trace(" state: %ld\n", m_triangles[i].state);
+        }
     }
 
     return true;
@@ -1197,6 +1204,10 @@ int CModelFile::GetTriangleCount()
     return m_triangles.size();
 }
 
+void CModelFile::SetPrintDebugInfo(bool printDebugInfo)
+{
+    m_printDebugInfo = printDebugInfo;
+}
 
 } // namespace Gfx
 
diff --git a/src/graphics/engine/modelfile.h b/src/graphics/engine/modelfile.h
index 9a01f78..3b4019b 100644
--- a/src/graphics/engine/modelfile.h
+++ b/src/graphics/engine/modelfile.h
@@ -137,6 +137,9 @@ public:
     //! Returns the triangle vector
     const std::vector<ModelTriangle>& GetTriangles();
 
+    //! Controls printing of debug information
+    void SetPrintDebugInfo(bool printDebugInfo);
+
 protected:
     //@{
     //! @deprecated min, max conversions
@@ -147,6 +150,7 @@ protected:
 protected:
     //! Model triangles
     std::vector<ModelTriangle> m_triangles;
+    bool m_printDebugInfo;
 };
 
 }; // namespace Gfx
diff --git a/src/graphics/engine/modelmanager.cpp b/src/graphics/engine/modelmanager.cpp
index 8397e15..abc8c6c 100644
--- a/src/graphics/engine/modelmanager.cpp
+++ b/src/graphics/engine/modelmanager.cpp
@@ -27,6 +27,9 @@ bool CModelManager::LoadModel(const std::string& fileName, bool mirrored)
 
     CModelFile modelFile;
 
+    if (CApplication::GetInstance().IsDebugModeActive(DEBUG_MODELS))
+        modelFile.SetPrintDebugInfo(true);
+
     std::string filePath = CApplication::GetInstance().GetDataFilePath(DIR_MODEL, fileName);
 
     if (!modelFile.ReadModel(filePath))
diff --git a/src/graphics/engine/pyro.cpp b/src/graphics/engine/pyro.cpp
index 0a85beb..7c51829 100644
--- a/src/graphics/engine/pyro.cpp
+++ b/src/graphics/engine/pyro.cpp
@@ -1556,7 +1556,14 @@ void CPyro::ExploStart()
     for (int i = 0; i < OBJECTMAXPART; i++)
     {
         int objRank = m_object->GetObjectRank(i);
-        if ( objRank == -1 )  continue;
+        if (objRank == -1)  continue;
+
+        // TODO: refactor later to material change
+        int oldBaseObjRank = m_engine->GetObjectBaseRank(objRank);
+        int newBaseObjRank = m_engine->CreateBaseObject();
+        m_engine->CopyBaseObject(oldBaseObjRank, newBaseObjRank);
+        m_engine->SetObjectBaseRank(objRank, newBaseObjRank);
+
         m_engine->ChangeSecondTexture(objRank, "dirty04.png");
 
         Math::Vector pos = m_object->GetPosition(i);
@@ -1618,6 +1625,13 @@ void CPyro::BurnStart()
     {
         int objRank = m_object->GetObjectRank(i);
         if (objRank == -1) continue;
+
+        // TODO: refactor later to material change
+        int oldBaseObjRank = m_engine->GetObjectBaseRank(objRank);
+        int newBaseObjRank = m_engine->CreateBaseObject();
+        m_engine->CopyBaseObject(oldBaseObjRank, newBaseObjRank);
+        m_engine->SetObjectBaseRank(objRank, newBaseObjRank);
+
         m_engine->ChangeSecondTexture(objRank, "dirty04.png");
     }
     m_engine->LoadTexture("dirty04.png");
@@ -2384,6 +2398,7 @@ void CPyro::LightOperFrame(float rTime)
     {
         if ( m_progress < m_lightOper[i].progress )
         {
+            assert(i > 0); // TODO: if assert fails, fix the code
             float progress = (m_progress-m_lightOper[i-1].progress) / (m_lightOper[i].progress-m_lightOper[i-1].progress);
 
             float intensity = m_lightOper[i-1].intensity + (m_lightOper[i].intensity-m_lightOper[i-1].intensity)*progress;
diff --git a/src/graphics/opengl/gldevice.cpp b/src/graphics/opengl/gldevice.cpp
index 4bfc542..bbabdd6 100644
--- a/src/graphics/opengl/gldevice.cpp
+++ b/src/graphics/opengl/gldevice.cpp
@@ -79,6 +79,106 @@ void CGLDevice::DebugHook()
     glColor3i(0, 0, 0);
 }
 
+void CGLDevice::DebugLights()
+{
+    Gfx::ColorHSV color(0.0, 1.0, 1.0);
+
+    glLineWidth(3.0f);
+    glDisable(GL_LIGHTING);
+    glDepthMask(GL_FALSE);
+    glDisable(GL_BLEND);
+
+    Math::Matrix saveWorldMat = m_worldMat;
+    m_worldMat.LoadIdentity();
+    UpdateModelviewMatrix();
+
+    for (int i = 0; i < static_cast<int>( m_lights.size() ); ++i)
+    {
+        color.h = static_cast<float>(i) / static_cast<float>(m_lights.size());
+        if (m_lightsEnabled[i])
+        {
+            const Light& l = m_lights[i];
+            if (l.type == LIGHT_DIRECTIONAL)
+            {
+                Gfx::VertexCol v[2];
+                v[0].coord = -Math::Normalize(l.direction) * 100.0f + Math::Vector(0.0f, 0.0f, 1.0f) * i;
+                v[0].color = HSV2RGB(color);
+                v[1].coord =  Math::Normalize(l.direction) * 100.0f + Math::Vector(0.0f, 0.0f, 1.0f) * i;
+                v[1].color = HSV2RGB(color);
+                while (v[0].coord.y < 60.0f && v[0].coord.y < 60.0f)
+                {
+                    v[0].coord.y += 10.0f;
+                    v[1].coord.y += 10.0f;
+                }
+                DrawPrimitive(PRIMITIVE_LINES, v, 2);
+
+                v[0].coord = v[1].coord + Math::Normalize(v[0].coord - v[1].coord) * 50.0f;
+
+                glLineWidth(10.0f);
+                DrawPrimitive(PRIMITIVE_LINES, v, 2);
+                glLineWidth(3.0f);
+            }
+            else  if (l.type == LIGHT_POINT)
+            {
+                Gfx::VertexCol v[8];
+                for (int i = 0; i < 8; ++i)
+                    v[i].color = HSV2RGB(color);
+
+                v[0].coord = l.position + Math::Vector(-1.0f, -1.0f, -1.0f) * 4.0f;
+                v[1].coord = l.position + Math::Vector( 1.0f, -1.0f, -1.0f) * 4.0f;
+                v[2].coord = l.position + Math::Vector( 1.0f,  1.0f, -1.0f) * 4.0f;
+                v[3].coord = l.position + Math::Vector(-1.0f,  1.0f, -1.0f) * 4.0f;
+                v[4].coord = l.position + Math::Vector(-1.0f, -1.0f, -1.0f) * 4.0f;
+                DrawPrimitive(PRIMITIVE_LINE_STRIP, v, 5);
+
+                v[0].coord = l.position + Math::Vector(-1.0f, -1.0f,  1.0f) * 4.0f;
+                v[1].coord = l.position + Math::Vector( 1.0f, -1.0f,  1.0f) * 4.0f;
+                v[2].coord = l.position + Math::Vector( 1.0f,  1.0f,  1.0f) * 4.0f;
+                v[3].coord = l.position + Math::Vector(-1.0f,  1.0f,  1.0f) * 4.0f;
+                v[4].coord = l.position + Math::Vector(-1.0f, -1.0f,  1.0f) * 4.0f;
+                DrawPrimitive(PRIMITIVE_LINE_STRIP, v, 5);
+
+                v[0].coord = l.position + Math::Vector(-1.0f, -1.0f, -1.0f) * 4.0f;
+                v[1].coord = l.position + Math::Vector(-1.0f, -1.0f,  1.0f) * 4.0f;
+                v[2].coord = l.position + Math::Vector( 1.0f, -1.0f, -1.0f) * 4.0f;
+                v[3].coord = l.position + Math::Vector( 1.0f, -1.0f,  1.0f) * 4.0f;
+                v[4].coord = l.position + Math::Vector( 1.0f,  1.0f, -1.0f) * 4.0f;
+                v[5].coord = l.position + Math::Vector( 1.0f,  1.0f,  1.0f) * 4.0f;
+                v[6].coord = l.position + Math::Vector(-1.0f,  1.0f, -1.0f) * 4.0f;
+                v[7].coord = l.position + Math::Vector(-1.0f,  1.0f,  1.0f) * 4.0f;
+                DrawPrimitive(PRIMITIVE_LINES, v, 8);
+            }
+            else if (l.type == LIGHT_SPOT)
+            {
+                Gfx::VertexCol v[5];
+                for (int i = 0; i < 5; ++i)
+                    v[i].color = HSV2RGB(color);
+
+                v[0].coord = l.position + Math::Vector(-1.0f,  0.0f, -1.0f) * 4.0f;
+                v[1].coord = l.position + Math::Vector( 1.0f,  0.0f, -1.0f) * 4.0f;
+                v[2].coord = l.position + Math::Vector( 1.0f,  0.0f,  1.0f) * 4.0f;
+                v[3].coord = l.position + Math::Vector(-1.0f,  0.0f,  1.0f) * 4.0f;
+                v[4].coord = l.position + Math::Vector(-1.0f,  0.0f, -1.0f) * 4.0f;
+                DrawPrimitive(PRIMITIVE_LINE_STRIP, v, 5);
+
+                v[0].coord = l.position;
+                v[1].coord = l.position + Math::Normalize(l.direction) * 100.0f;
+                glEnable(GL_LINE_STIPPLE);
+                glLineStipple(3.0, 0xFF);
+                DrawPrimitive(PRIMITIVE_LINES, v, 2);
+                glDisable(GL_LINE_STIPPLE);
+            }
+        }
+    }
+
+    glLineWidth(1.0f);
+    glEnable(GL_LIGHTING);
+    glDepthMask(GL_TRUE);
+    glEnable(GL_BLEND);
+    m_worldMat = saveWorldMat;
+    UpdateModelviewMatrix();
+}
+
 bool CGLDevice::Create()
 {
     GetLogger()->Info("Creating CDevice\n");
diff --git a/src/graphics/opengl/gldevice.h b/src/graphics/opengl/gldevice.h
index 004a18b..c648161 100644
--- a/src/graphics/opengl/gldevice.h
+++ b/src/graphics/opengl/gldevice.h
@@ -93,6 +93,7 @@ public:
     virtual ~CGLDevice();
 
     virtual void DebugHook();
+    virtual void DebugLights();
 
     virtual bool Create();
     virtual void Destroy();
diff --git a/src/math/matrix.h b/src/math/matrix.h
index a13f823..f139517 100644
--- a/src/math/matrix.h
+++ b/src/math/matrix.h
@@ -97,8 +97,8 @@ struct Matrix
 
     //! Sets value in given row and col
     /**
-     * \param row row (0 to 3)
-     * \param col column (0 to 3)
+     * \param row row (1 to 4)
+     * \param col column (1 to 4)
      * \param value value
      */
     inline void Set(int row, int col, float value)
@@ -108,8 +108,8 @@ struct Matrix
 
     //! Returns the value in given row and col
     /**
-     * \param row row (0 to 3)
-     * \param col column (0 to 3)
+     * \param row row (1 to 4)
+     * \param col column (1 to 4)
      * \returns value
      */
     inline float Get(int row, int col)
diff --git a/src/object/robotmain.cpp b/src/object/robotmain.cpp
index 27492f3..7eaa3f6 100644
--- a/src/object/robotmain.cpp
+++ b/src/object/robotmain.cpp
@@ -940,6 +940,14 @@ Ui::CDisplayText* CRobotMain::GetDisplayText()
     return m_displayText;
 }
 
+void CRobotMain::LoadSceneOnStart(const std::string& name, int rank)
+{
+    // TODO: fix this ugly dependency :(
+    m_dialog->SetSceneName(name.c_str());
+    m_dialog->SetSceneRank(rank);
+    ChangePhase(PHASE_LOADING);
+}
+
 
 //! Creates the file colobot.ini at the first time
 void CRobotMain::CreateIni()
@@ -1010,28 +1018,24 @@ void CRobotMain::SetDefaultInputBindings()
 void CRobotMain::SetInputBinding(InputSlot slot, InputBinding binding)
 {
     unsigned int index = static_cast<unsigned int>(slot);
-    assert(index >= 0 && index < INPUT_SLOT_MAX);
     m_inputBindings[index] = binding;
 }
 
 const InputBinding& CRobotMain::GetInputBinding(InputSlot slot)
 {
     unsigned int index = static_cast<unsigned int>(slot);
-    assert(index >= 0 && index < INPUT_SLOT_MAX);
     return m_inputBindings[index];
 }
 
 void CRobotMain::SetJoyAxisBinding(JoyAxisSlot slot, JoyAxisBinding binding)
 {
     unsigned int index = static_cast<unsigned int>(slot);
-    assert(index >= 0 && index < JOY_AXIS_SLOT_MAX);
     m_joyAxisBindings[index] = binding;
 }
 
 const JoyAxisBinding& CRobotMain::GetJoyAxisBinding(JoyAxisSlot slot)
 {
     unsigned int index = static_cast<unsigned int>(slot);
-    assert(index >= 0 && index < JOY_AXIS_SLOT_MAX);
     return m_joyAxisBindings[index];
 }
 
@@ -1196,6 +1200,8 @@ void CRobotMain::ChangePhase(Phase phase)
         if (m_mapImage)
             m_map->SetFixImage(m_mapFilename);
 
+        m_app->ResetTimeAfterLoading();
+
         /*Math::Point ddim;
 
         pos.x = 620.0f/640.0f;
@@ -1298,7 +1304,7 @@ void CRobotMain::ChangePhase(Phase phase)
 }
 
 //! Processes an event
-bool CRobotMain::EventProcess(Event &event)
+bool CRobotMain::ProcessEvent(Event &event)
 {
     /* Motion vector management */
 
@@ -1995,7 +2001,14 @@ void CRobotMain::ExecuteCmd(char *cmd)
 
     if (strcmp(cmd, "debugmode") == 0)
     {
-        m_app->SetDebugMode(!m_app->GetDebugMode());
+        if (m_app->IsDebugModeActive(DEBUG_ALL))
+        {
+            m_app->SetDebugModeActive(DEBUG_ALL, false);
+        }
+        else
+        {
+            m_app->SetDebugModeActive(DEBUG_ALL, true);
+        }
         return;
     }
 
@@ -4082,8 +4095,8 @@ void CRobotMain::CreateScene(bool soluce, bool fixScene, bool resetObject)
 
         if (Cmd(line, "CacheAudio") && !resetObject && m_version >= 2)
         {
-            OpString(line, "filename", filename);
-            m_sound->CacheMusic(filename);
+            OpString(line, "filename", name);
+            m_sound->CacheMusic(name);
             continue;
         }
 
@@ -4771,7 +4784,10 @@ void CRobotMain::CreateScene(bool soluce, bool fixScene, bool resetObject)
 
             type = OpTypeTerrain(line, "type", Gfx::ENG_OBJTYPE_NULL);
             if (type == Gfx::ENG_OBJTYPE_TERRAIN)
+            {
+                m_lightMan->SetLightPriority(lightRank, Gfx::LIGHT_PRI_HIGHEST);
                 m_lightMan->SetLightIncludeType(lightRank, Gfx::ENG_OBJTYPE_TERRAIN);
+            }
 
             if (type == Gfx::ENG_OBJTYPE_QUARTZ)
                 m_lightMan->SetLightIncludeType(lightRank, Gfx::ENG_OBJTYPE_QUARTZ);
diff --git a/src/object/robotmain.h b/src/object/robotmain.h
index a75509d..04efea7 100644
--- a/src/object/robotmain.h
+++ b/src/object/robotmain.h
@@ -199,6 +199,9 @@ public:
     Ui::CInterface* GetInterface();
     Ui::CDisplayText* GetDisplayText();
 
+    //! Caused the given mission to be loaded immediately after start
+    void        LoadSceneOnStart(const std::string& name, int rank);
+
     void        CreateIni();
 
     //! Sets the default input bindings (key and axes)
@@ -226,7 +229,7 @@ public:
     void        ResetKeyStates();
 
     void        ChangePhase(Phase phase);
-    bool        EventProcess(Event &event);
+    bool        ProcessEvent(Event &event);
 
     bool        CreateShortcuts();
     void        ScenePerso();
diff --git a/src/ui/maindialog.cpp b/src/ui/maindialog.cpp
index 8f5b936..3a31883 100644
--- a/src/ui/maindialog.cpp
+++ b/src/ui/maindialog.cpp
@@ -366,7 +366,8 @@ pb->SetState(STATE_SHADOW);
         }
         // #endif
 
-        if ( m_app->GetDebugMode() )
+        // TODO: remove?
+        if (m_app->GetProtoMode())
         {
             pos.x  = 139.0f/640.0f;
             pos.y  = 313.0f/480.0f;
diff --git a/test/envs/opengl/CMakeLists.txt b/test/envs/opengl/CMakeLists.txt
index 0bcb43d..c52b8b4 100644
--- a/test/envs/opengl/CMakeLists.txt
+++ b/test/envs/opengl/CMakeLists.txt
@@ -12,6 +12,7 @@ else()
 endif()
 
 set(TEXTURE_SOURCES
+${SRC_DIR}/graphics/core/color.cpp
 ${SRC_DIR}/graphics/opengl/gldevice.cpp
 ${SRC_DIR}/common/logger.cpp
 ${SRC_DIR}/common/image.cpp
@@ -19,6 +20,7 @@ texture_test.cpp
 )
 
 set(MODEL_SOURCES
+${SRC_DIR}/graphics/core/color.cpp
 ${SRC_DIR}/graphics/opengl/gldevice.cpp
 ${SRC_DIR}/graphics/engine/modelfile.cpp
 ${SRC_DIR}/common/logger.cpp
@@ -30,6 +32,7 @@ model_test.cpp
 )
 
 set(TRANSFORM_SOURCES
+${SRC_DIR}/graphics/core/color.cpp
 ${SRC_DIR}/graphics/opengl/gldevice.cpp
 ${SRC_DIR}/common/logger.cpp
 ${SRC_DIR}/common/image.cpp
@@ -39,6 +42,7 @@ transform_test.cpp
 )
 
 set(LIGHT_SOURCES
+${SRC_DIR}/graphics/core/color.cpp
 ${SRC_DIR}/graphics/opengl/gldevice.cpp
 ${SRC_DIR}/common/logger.cpp
 ${SRC_DIR}/common/image.cpp
diff --git a/test/unit/CMakeLists.txt b/test/unit/CMakeLists.txt
index 3b983ca..994777f 100644
--- a/test/unit/CMakeLists.txt
+++ b/test/unit/CMakeLists.txt
@@ -207,7 +207,7 @@ ${GLEW_INCLUDE_PATH}
 ${Boost_INCLUDE_DIRS}
 ${OPTIONAL_INCLUDE_DIRS}
 ${LIBSNDFILE_INCLUDE_DIR}
-${CLIPBOARD_DIR}
+${CLIPBOARD_INCLUDE_DIR}
 )
 
 set(LIBS
diff --git a/test/unit/graphics/core/device_mock.h b/test/unit/graphics/core/device_mock.h
index 80e214f..9e75daf 100644
--- a/test/unit/graphics/core/device_mock.h
+++ b/test/unit/graphics/core/device_mock.h
@@ -10,6 +10,7 @@ public:
     CDeviceMock() {}
 
     MOCK_METHOD0(DebugHook, void());
+    MOCK_METHOD0(DebugLights, void());
 
     MOCK_METHOD0(Create, bool());
     MOCK_METHOD0(Destroy, void());
diff --git a/test/unit/ui/CMakeLists.txt b/test/unit/ui/CMakeLists.txt
index 148e45e..842f49d 100644
--- a/test/unit/ui/CMakeLists.txt
+++ b/test/unit/ui/CMakeLists.txt
@@ -5,7 +5,7 @@ include_directories(
 ${SRC_DIR}
 ${GTEST_INCLUDE_DIR}
 ${GMOCK_INCLUDE_DIR}
-${CLIPBOARD_DIR}
+${CLIPBOARD_INCLUDE_DIR}
 )
 
 # Platform-dependent implementation of CSystemUtils